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

omnibase_infra/nodes/node_registration_orchestrator/handlers/handler_node_introspected.py

@@ -53,6 +53,7 @@ Related Tickets:
 from __future__ import annotations
 
 import logging
+import re
 import time
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING
@@ -237,6 +238,39 @@ class HandlerNodeIntrospected:
         """Check if HandlerConsul is configured for Consul registration."""
         return self._consul_handler is not None
 
+    def _sanitize_tool_name(self, name: str) -> str:
+        """Sanitize tool name for use in Consul tags.
+
+        Converts free-form text (like descriptions) into stable, Consul-safe
+        identifiers. This ensures consistent service discovery matching.
+
+        Transformation rules:
+            1. Convert to lowercase
+            2. Replace non-alphanumeric characters with dashes
+            3. Collapse multiple consecutive dashes into one
+            4. Remove leading/trailing dashes
+            5. Truncate to 63 characters (Consul tag limit)
+
+        Args:
+            name: Raw tool name or description text.
+
+        Returns:
+            Sanitized string suitable for Consul tags (lowercase, alphanumeric
+            with dashes, max 63 chars).
+
+        Example:
+            >>> handler._sanitize_tool_name("My Cool Tool (v2.0)")
+            'my-cool-tool-v2-0'
+            >>> handler._sanitize_tool_name("  Spaces & Special!Chars  ")
+            'spaces-special-chars'
+        """
+        # Replace non-alphanumeric with dash, lowercase
+        sanitized = re.sub(r"[^a-zA-Z0-9]+", "-", name.lower())
+        # Remove leading/trailing dashes
+        sanitized = sanitized.strip("-")
+        # Truncate to Consul tag limit (63 chars is common limit for DNS labels)
+        return sanitized[:63]
+
     async def handle(
         self,
         envelope: ModelEventEnvelope[ModelNodeIntrospectionEvent],
@@ -422,11 +456,19 @@ class HandlerNodeIntrospected:
 
         # Register with Consul for service discovery (dual registration)
         # This happens AFTER PostgreSQL persistence (source of truth)
+        # Pass MCP config from capabilities (if present) for MCP tag generation
+        mcp_config = (
+            event.declared_capabilities.mcp
+            if event.declared_capabilities is not None
+            else None
+        )
         await self._register_with_consul(
             node_id=node_id,
             node_type=event.node_type.value,
             endpoints=event.endpoints,
             correlation_id=correlation_id,
+            mcp_config=mcp_config,
+            node_name=event.metadata.description if event.metadata else None,
         )
 
         logger.info(
@@ -458,6 +500,8 @@ class HandlerNodeIntrospected:
         node_type: str,
         endpoints: dict[str, str] | None,
         correlation_id: UUID,
+        mcp_config: object | None = None,
+        node_name: str | None = None,
     ) -> None:
         """Register node with Consul for service discovery.
 
@@ -465,8 +509,16 @@ class HandlerNodeIntrospected:
         - service_name: `onex-{node_type}` (ONEX convention for service discovery)
         - service_id: `onex-{node_type}-{node_id}` (unique identifier)
         - tags: [`onex`, `node-type:{node_type}`]
+        - MCP tags (orchestrators only): [`mcp-enabled`, `mcp-tool:{tool_name}`]
         - address/port: Extracted from endpoints if available
 
+        MCP Tags:
+            MCP tags are added ONLY when:
+            1. node_type is "orchestrator"
+            2. mcp_config is provided with expose=True
+
+            This ensures only orchestrators can be exposed as MCP tools.
+
         This method is idempotent - re-registering the same service_id updates it.
         Errors are logged but not propagated (PostgreSQL is source of truth).
 
@@ -475,6 +527,8 @@ class HandlerNodeIntrospected:
             node_type: ONEX node type (effect, compute, reducer, orchestrator).
             endpoints: Optional dict of endpoint URLs from introspection event.
             correlation_id: Correlation ID for tracing.
+            mcp_config: Optional MCP configuration from capabilities.
+            node_name: Optional node name for MCP tool naming.
         """
         if self._consul_handler is None:
             logger.debug(
@@ -554,11 +608,42 @@ class HandlerNodeIntrospected:
                         },
                     )
 
+        # Build base tags
+        tags: list[str] = ["onex", f"node-type:{node_type}"]
+
+        # Add MCP tags for orchestrators with MCP config enabled
+        # MCP tags are ONLY added when:
+        # 1. node_type is "orchestrator" (enforces orchestrator-only rule)
+        # 2. mcp_config exists with expose=True
+        if node_type == "orchestrator" and mcp_config is not None:
+            # Check if mcp_config has expose attribute and it's True
+            mcp_expose = getattr(mcp_config, "expose", False)
+            if mcp_expose:
+                # Get tool name from mcp_config or fall back to node_name
+                mcp_tool_name_raw = getattr(mcp_config, "tool_name", None)
+                if not mcp_tool_name_raw:
+                    # Fall back to node_name (description), then service_name
+                    mcp_tool_name_raw = node_name or service_name
+                # Sanitize tool name for Consul tag safety
+                # node_name comes from metadata.description which can be free-form text
+                mcp_tool_name = self._sanitize_tool_name(mcp_tool_name_raw)
+                tags.extend(["mcp-enabled", f"mcp-tool:{mcp_tool_name}"])
+
+                logger.info(
+                    "Adding MCP tags to Consul registration",
+                    extra={
+                        "node_id": str(node_id),
+                        "tool_name": mcp_tool_name,
+                        "tool_name_raw": mcp_tool_name_raw,
+                        "correlation_id": str(correlation_id),
+                    },
+                )
+
         # Build Consul registration payload
         consul_payload: dict[str, object] = {
             "name": service_name,
             "service_id": service_id,
-            "tags": ["onex", f"node-type:{node_type}"],
+            "tags": tags,
         }
         if address:
             consul_payload["address"] = address

omnibase_infra/nodes/node_registration_orchestrator/introspection_event_router.py

@@ -392,7 +392,7 @@ class IntrospectionEventRouter:
                 correlation_id=raw_envelope.correlation_id or callback_correlation_id,
                 source_tool=raw_envelope.source_tool,
                 target_tool=raw_envelope.target_tool,
-                metadata=_normalize_metadata(raw_envelope.metadata),
+                metadata=_normalize_metadata(raw_envelope.metadata),  # type: ignore[arg-type]
                 priority=raw_envelope.priority,
                 timeout_seconds=raw_envelope.timeout_seconds,
                 trace_id=raw_envelope.trace_id,
@@ -419,7 +419,7 @@ class IntrospectionEventRouter:
                 },
             )
             dispatcher_start_time = time.time()
-            result = await self._dispatcher.handle(event_envelope)
+            result = await self._dispatcher.handle(event_envelope)  # type: ignore[arg-type]
             dispatcher_duration = time.time() - dispatcher_start_time
 
             if result.is_successful():
@@ -441,7 +441,7 @@ class IntrospectionEventRouter:
                 if result.output_events:
                     for output_event in result.output_events:
                         # Wrap output event in envelope
-                        output_envelope = ModelEventEnvelope(
+                        output_envelope = ModelEventEnvelope(  # type: ignore[var-annotated]
                             payload=output_event,
                             correlation_id=event_envelope.correlation_id,
                             envelope_timestamp=datetime.now(UTC),

omnibase_infra/nodes/node_registration_orchestrator/registry/registry_infra_node_registration_orchestrator.py

@@ -13,7 +13,7 @@ Handler Wiring (from contract.yaml):
     - ModelNodeHeartbeatEvent -> HandlerNodeHeartbeat
 
 Handler Implementation:
-    All handlers implement ProtocolMessageHandler directly with:
+    All handlers implement ProtocolHandler directly with:
     - handler_id, category, message_types, node_kind properties
     - handle(envelope) -> ModelHandlerOutput signature
 
@@ -88,7 +88,7 @@ from __future__ import annotations
 import importlib
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from omnibase_core.services.service_handler_registry import ServiceHandlerRegistry
 from omnibase_infra.enums import EnumInfraTransportType
@@ -96,6 +96,7 @@ from omnibase_infra.errors import ModelInfraErrorContext, ProtocolConfigurationE
 from omnibase_infra.runtime.contract_loaders import (
     load_handler_class_info_from_contract,
 )
+from omnibase_spi.protocols.handlers import ProtocolHandler
 
 logger = logging.getLogger(__name__)
 
@@ -110,14 +111,14 @@ ALLOWED_NAMESPACES: tuple[str, ...] = (
 
 
 def _validate_handler_protocol(handler: object) -> tuple[bool, list[str]]:
-    """Validate handler implements ProtocolMessageHandler via duck typing.
+    """Validate handler implements ProtocolHandler via duck typing.
 
     Uses duck typing to verify the handler has the required properties and
-    methods for ProtocolMessageHandler compliance. Per ONEX conventions,
+    methods for ProtocolHandler compliance. Per ONEX conventions,
     protocol compliance is verified via structural typing rather than
     isinstance checks.
 
-    Protocol Requirements (ProtocolMessageHandler):
+    Protocol Requirements (ProtocolHandler):
         - handler_id (property): Unique identifier string
         - category (property): EnumMessageCategory value
         - message_types (property): set[str] of message type names
@@ -492,7 +493,7 @@ class RegistryInfraNodeRegistrationOrchestrator:
                     context=ctx,
                 ) from e
 
-            # Validate handler implements ProtocolMessageHandler
+            # Validate handler implements ProtocolHandler
             is_valid, missing = _validate_handler_protocol(handler_instance)
             if not is_valid:
                 ctx = ModelInfraErrorContext.with_correlation(
@@ -501,7 +502,7 @@ class RegistryInfraNodeRegistrationOrchestrator:
                     target_name=handler_class_name,
                 )
                 raise ProtocolConfigurationError(
-                    f"Handler '{handler_class_name}' does not implement ProtocolMessageHandler. "
+                    f"Handler '{handler_class_name}' does not implement ProtocolHandler. "
                     f"Missing required members: {', '.join(missing)}. "
                     f"Handlers must have: handler_id, category, message_types, node_kind properties "
                     f"and handle(envelope) method. "
@@ -510,7 +511,7 @@ class RegistryInfraNodeRegistrationOrchestrator:
                 )
 
             # Register handler
-            registry.register_handler(handler_instance)
+            registry.register_handler(handler_instance)  # type: ignore[arg-type]
             logger.debug(
                 "Registered handler from contract: %s",
                 handler_class_name,

omnibase_infra/nodes/node_registration_orchestrator/wiring.py

@@ -44,6 +44,7 @@ import logging
 from typing import TYPE_CHECKING, TypedDict, cast
 from uuid import UUID
 
+from omnibase_core.enums import EnumInjectionScope
 from omnibase_infra.enums import EnumInfraTransportType
 from omnibase_infra.errors import (
     ContainerValidationError,
@@ -269,12 +270,14 @@ async def wire_registration_dispatchers(
         # because MessageDispatchEngine.register_dispatcher() takes a callable
 
         # 3a. Register DispatcherNodeIntrospected
+        # Note: node_kind is NOT passed to register_dispatcher because the dispatcher's
+        # handle() method doesn't accept ModelDispatchContext - it handles time injection
+        # internally. The node_kind property is informational only.
         engine.register_dispatcher(
             dispatcher_id=dispatcher_introspected.dispatcher_id,
             dispatcher=dispatcher_introspected.handle,
             category=dispatcher_introspected.category,
             message_types=dispatcher_introspected.message_types,
-            node_kind=dispatcher_introspected.node_kind,
         )
         dispatchers_registered.append(dispatcher_introspected.dispatcher_id)
 
@@ -284,7 +287,6 @@ async def wire_registration_dispatchers(
             dispatcher=dispatcher_runtime_tick.handle,
             category=dispatcher_runtime_tick.category,
             message_types=dispatcher_runtime_tick.message_types,
-            node_kind=dispatcher_runtime_tick.node_kind,
         )
         dispatchers_registered.append(dispatcher_runtime_tick.dispatcher_id)
 
@@ -294,7 +296,6 @@ async def wire_registration_dispatchers(
             dispatcher=dispatcher_acked.handle,
             category=dispatcher_acked.category,
             message_types=dispatcher_acked.message_types,
-            node_kind=dispatcher_acked.node_kind,
         )
         dispatchers_registered.append(dispatcher_acked.dispatcher_id)
 
@@ -409,7 +410,7 @@ async def wire_registration_handlers(
         ContainerWiringError: If service registration fails.
 
     Note:
-        Services are registered with scope="global" and may conflict if multiple
+        Services are registered with scope=EnumInjectionScope.GLOBAL and may conflict if multiple
         plugins register the same interface type. This is acceptable for the
         Registration domain as these handlers are singletons by design. If you
         need to register multiple implementations of the same interface, use
@@ -440,7 +441,7 @@ async def wire_registration_handlers(
         await container.service_registry.register_instance(
             interface=ProjectionReaderRegistration,
             instance=projection_reader,
-            scope="global",
+            scope=EnumInjectionScope.GLOBAL,
             metadata={
                 "description": "Registration projection reader",
                 "version": str(semver_default),
@@ -453,7 +454,7 @@ async def wire_registration_handlers(
             await container.service_registry.register_instance(
                 interface=ProjectorShell,
                 instance=projector,
-                scope="global",
+                scope=EnumInjectionScope.GLOBAL,
                 metadata={
                     "description": "Registration projector",
                     "version": str(semver_default),
@@ -470,7 +471,7 @@ async def wire_registration_handlers(
         await container.service_registry.register_instance(
             interface=HandlerNodeIntrospected,
             instance=handler_introspected,
-            scope="global",
+            scope=EnumInjectionScope.GLOBAL,
             metadata={
                 "description": "Handler for NodeIntrospectionEvent",
                 "version": str(semver_default),
@@ -485,7 +486,7 @@ async def wire_registration_handlers(
         await container.service_registry.register_instance(
             interface=HandlerRuntimeTick,
             instance=handler_runtime_tick,
-            scope="global",
+            scope=EnumInjectionScope.GLOBAL,
             metadata={
                 "description": "Handler for RuntimeTick",
                 "version": str(semver_default),
@@ -501,7 +502,7 @@ async def wire_registration_handlers(
         await container.service_registry.register_instance(
             interface=HandlerNodeRegistrationAcked,
             instance=handler_acked,
-            scope="global",
+            scope=EnumInjectionScope.GLOBAL,
             metadata={
                 "description": "Handler for NodeRegistrationAcked",
                 "version": str(semver_default),
@@ -579,7 +580,7 @@ async def get_projection_reader_from_container(
     _validate_service_registry(container, "resolve ProjectionReaderRegistration")
     try:
         return cast(
-            ProjectionReaderRegistration,
+            "ProjectionReaderRegistration",
             await container.service_registry.resolve_service(
                 ProjectionReaderRegistration
             ),
@@ -622,7 +623,7 @@ async def get_handler_node_introspected_from_container(
     _validate_service_registry(container, "resolve HandlerNodeIntrospected")
     try:
         return cast(
-            HandlerNodeIntrospected,
+            "HandlerNodeIntrospected",
             await container.service_registry.resolve_service(HandlerNodeIntrospected),
         )
     except Exception as e:
@@ -663,7 +664,7 @@ async def get_handler_runtime_tick_from_container(
     _validate_service_registry(container, "resolve HandlerRuntimeTick")
     try:
         return cast(
-            HandlerRuntimeTick,
+            "HandlerRuntimeTick",
             await container.service_registry.resolve_service(HandlerRuntimeTick),
         )
     except Exception as e:
@@ -704,7 +705,7 @@ async def get_handler_node_registration_acked_from_container(
     _validate_service_registry(container, "resolve HandlerNodeRegistrationAcked")
     try:
         return cast(
-            HandlerNodeRegistrationAcked,
+            "HandlerNodeRegistrationAcked",
             await container.service_registry.resolve_service(
                 HandlerNodeRegistrationAcked
             ),

omnibase_infra/nodes/node_registration_storage_effect/contract.yaml

@@ -15,11 +15,6 @@
 name: "node_registration_storage_effect"
 contract_name: "node_registration_storage_effect"
 node_name: "node_registration_storage_effect"
-# Version (semantic versioning)
-version:
-  major: 1
-  minor: 0
-  patch: 0
 contract_version:
   major: 1
   minor: 0

omnibase_infra/nodes/node_registration_storage_effect/registry/registry_infra_registration_storage.py

@@ -17,6 +17,12 @@ Related:
     - NodeRegistrationStorageEffect: Effect node that uses these dependencies
     - ProtocolRegistrationPersistence: Protocol for storage backends
     - ModelONEXContainer: ONEX dependency injection container
+
+Note:
+    This registry uses a module-level dict for handler storage because the
+    ServiceRegistry in omnibase_core v1.0 doesn't support dict-style access
+    or string-keyed multi-handler routing. The handlers are still validated
+    against the protocol but stored separately.
 """
 
 from __future__ import annotations
@@ -31,6 +37,12 @@ if TYPE_CHECKING:
 
 __all__ = ["RegistryInfraRegistrationStorage"]
 
+# Module-level storage for handlers and metadata
+# ServiceRegistry in v1.0 doesn't support dict-style access needed for
+# multi-handler routing (e.g., "postgresql", "mock" handler types)
+_HANDLER_STORAGE: dict[str, object] = {}
+_PROTOCOL_METADATA: dict[str, dict[str, object]] = {}
+
 
 class RegistryInfraRegistrationStorage:
     """Registry for registration storage node dependencies.
@@ -72,14 +84,18 @@ class RegistryInfraRegistrationStorage:
     DEFAULT_HANDLER_TYPE = "postgresql"
 
     @staticmethod
-    def register(container: ModelONEXContainer) -> None:
+    def register(_container: ModelONEXContainer) -> None:
         """Register registration storage dependencies with the container.
 
         Registers the protocol key for later handler binding. This method
         sets up the infrastructure but does not bind a specific handler.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency with other registry methods and future migration
+                when ServiceRegistry supports the required access patterns.
 
         Example:
             >>> from omnibase_core.models.container import ModelONEXContainer
@@ -88,20 +104,19 @@ class RegistryInfraRegistrationStorage:
         """
         # Register protocol metadata for discovery
         # Actual handler binding happens via register_handler()
-        if container.service_registry is not None:
-            container.service_registry[
-                RegistryInfraRegistrationStorage.PROTOCOL_KEY
-            ] = {
-                "protocol": "ProtocolRegistrationPersistence",
-                "module": "omnibase_infra.nodes.node_registration_storage_effect.protocols",
-                "description": "Protocol for registration storage backends",
-                "pluggable": True,
-                "implementations": ["postgresql", "mock"],
-            }
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
+        _PROTOCOL_METADATA[RegistryInfraRegistrationStorage.PROTOCOL_KEY] = {
+            "protocol": "ProtocolRegistrationPersistence",
+            "module": "omnibase_infra.nodes.node_registration_storage_effect.protocols",
+            "description": "Protocol for registration storage backends",
+            "pluggable": True,
+            "implementations": ["postgresql", "mock"],
+        }
 
     @staticmethod
     def register_handler(
-        container: ModelONEXContainer,
+        _container: ModelONEXContainer,
         handler: ProtocolRegistrationPersistence,
     ) -> None:
         """Register a specific storage handler with the container.
@@ -110,7 +125,11 @@ class RegistryInfraRegistrationStorage:
         The handler must implement ProtocolRegistrationPersistence.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency and future migration when ServiceRegistry supports
+                the required access patterns.
             handler: Handler implementation to register.
 
         Raises:
@@ -143,32 +162,35 @@ class RegistryInfraRegistrationStorage:
                 f"got {type(handler).__name__}"
             )
 
-        if container.service_registry is None:
-            return
-
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
         handler_key = (
             f"{RegistryInfraRegistrationStorage.PROTOCOL_KEY}.{handler.handler_type}"
         )
-        container.service_registry[handler_key] = handler
+        _HANDLER_STORAGE[handler_key] = handler
 
         # Also register as default if it matches the default type
         if (
             handler.handler_type
             == RegistryInfraRegistrationStorage.DEFAULT_HANDLER_TYPE
         ):
-            container.service_registry[
+            _HANDLER_STORAGE[
                 RegistryInfraRegistrationStorage.PROTOCOL_KEY + ".default"
             ] = handler
 
     @staticmethod
     def get_handler(
-        container: ModelONEXContainer,
+        _container: ModelONEXContainer,
         handler_type: str | None = None,
     ) -> ProtocolRegistrationPersistence | None:
         """Retrieve a registered storage handler from the container.
 
         Args:
-            container: ONEX dependency injection container.
+            _container: ONEX dependency injection container. Currently unused
+                because ServiceRegistry v1.0 doesn't support dict-style access
+                for multi-handler routing. The parameter is retained for API
+                consistency and future migration when ServiceRegistry supports
+                the required access patterns.
             handler_type: Specific handler type to retrieve. If None, returns default.
 
         Returns:
@@ -180,9 +202,8 @@ class RegistryInfraRegistrationStorage:
             ...     handler_type="postgresql",
             ... )
         """
-        if container.service_registry is None:
-            return None
-
+        # Note: Uses module-level storage since ServiceRegistry v1.0 doesn't
+        # support dict-style access for multi-handler routing
         if handler_type is not None:
             handler_key = (
                 f"{RegistryInfraRegistrationStorage.PROTOCOL_KEY}.{handler_type}"
@@ -190,5 +211,5 @@ class RegistryInfraRegistrationStorage:
         else:
             handler_key = RegistryInfraRegistrationStorage.PROTOCOL_KEY + ".default"
 
-        result = container.service_registry.get(handler_key)
+        result = _HANDLER_STORAGE.get(handler_key)
         return cast("ProtocolRegistrationPersistence | None", result)

omnibase_infra/nodes/node_registry_effect/contract.yaml

@@ -12,11 +12,6 @@
 name: "node_registry_effect"
 contract_name: "node_registry_effect"
 node_name: "node_registry_effect"
-# Version (semantic versioning)
-version:
-  major: 1
-  minor: 1
-  patch: 0
 contract_version:
   major: 1
   minor: 1

omnibase_infra/nodes/node_registry_effect/handlers/handler_partial_retry.py

@@ -41,6 +41,7 @@ import time
 from typing import TYPE_CHECKING, Protocol, runtime_checkable
 from uuid import UUID
 
+from omnibase_core.models.primitives import ModelSemVer
 from omnibase_infra.enums import EnumBackendType
 from omnibase_infra.errors import (
     InfraAuthenticationError,
@@ -80,7 +81,7 @@ class ProtocolPartialRetryRequest(Protocol):
 
     node_id: UUID
     node_type: EnumNodeKind
-    node_version: str
+    node_version: ModelSemVer
     target_backend: EnumBackendType
     idempotency_key: str | None
     service_name: str | None

omnibase_infra/nodes/node_service_discovery_effect/registry/registry_infra_service_discovery.py

@@ -40,6 +40,7 @@ Related:
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING
 
 from omnibase_infra.errors import ProtocolConfigurationError
@@ -50,6 +51,8 @@ if TYPE_CHECKING:
         ProtocolDiscoveryOperations,
     )
 
+logger = logging.getLogger(__name__)
+
 
 class RegistryInfraServiceDiscovery:
     """Registry for service discovery node dependencies.
@@ -59,11 +62,11 @@ class RegistryInfraServiceDiscovery:
     registration and explicit handler configuration.
 
     API Pattern Note:
-        This registry uses ``container.register_factory()`` and
-        ``container.register_instance()`` for protocol-based type-safe DI
-        resolution. This differs from RegistryInfraRegistrationStorage which
-        uses ``container.service_registry[key]`` dict access for multi-handler
-        routing by type string (e.g., "postgresql", "mock").
+        This registry uses ``container.service_registry.register_instance()``
+        for protocol-based type-safe DI resolution. This differs from
+        RegistryInfraRegistrationStorage which uses a module-level dict for
+        multi-handler routing by type string (e.g., "postgresql", "mock"),
+        as ServiceRegistry does not support dict-style indexed access.
 
         The different patterns serve different purposes:
         - Protocol-based registration: Single handler per protocol type
@@ -113,21 +116,18 @@ class RegistryInfraServiceDiscovery:
         if container.service_registry is None:
             return
 
-        # Import here to avoid circular imports
-        from omnibase_infra.nodes.node_service_discovery_effect.protocols import (
-            ProtocolDiscoveryOperations,
-        )
-
-        # Register protocol with lazy resolution
-        # The actual implementation is determined at resolution time
-        # based on configuration (CONSUL_AGENT_URL, K8S_NAMESPACE, etc.)
-        container.register_factory(
-            ProtocolDiscoveryOperations,
-            RegistryInfraServiceDiscovery._create_handler_from_config,
+        # NOTE: Factory registration (register_factory) is not implemented in
+        # omnibase_core v1.0. This method provides no-op registration for forward
+        # compatibility. Use register_with_handler() to explicitly provide a
+        # pre-configured handler instance.
+        logger.debug(
+            "Service discovery factory registration skipped - "
+            "factory registration not implemented in v1.0. "
+            "Use register_with_handler() to register an explicit handler instance."
         )
 
     @staticmethod
-    def register_with_handler(
+    async def register_with_handler(
         container: ModelONEXContainer,
         handler: ProtocolDiscoveryOperations,
     ) -> None:
@@ -146,12 +146,13 @@ class RegistryInfraServiceDiscovery:
         Example:
             >>> container = ModelONEXContainer()
             >>> handler = HandlerServiceDiscoveryConsul(config)
-            >>> RegistryInfraServiceDiscovery.register_with_handler(
+            >>> await RegistryInfraServiceDiscovery.register_with_handler(
             ...     container,
             ...     handler=handler,
             ... )
         """
         # Import at runtime for isinstance check (protocol is @runtime_checkable)
+        from omnibase_core.enums import EnumInjectionScope
         from omnibase_infra.nodes.node_service_discovery_effect.protocols import (
             ProtocolDiscoveryOperations,
         )
@@ -174,7 +175,11 @@ class RegistryInfraServiceDiscovery:
         if container.service_registry is None:
             return
 
-        container.register_instance(ProtocolDiscoveryOperations, handler)
+        await container.service_registry.register_instance(
+            interface=ProtocolDiscoveryOperations,  # type: ignore[type-abstract]
+            instance=handler,
+            scope=EnumInjectionScope.GLOBAL,
+        )
 
     @staticmethod
     def _create_handler_from_config(