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

omnibase_infra/nodes/architecture_validator/contract_architecture_validator.yaml

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

omnibase_infra/nodes/architecture_validator/registry/registry_infra_architecture_validator.py

@@ -39,7 +39,7 @@ class RegistryInfraArchitectureValidator:
 
     This registry provides a static method to register the NodeArchitectureValidator
     with the ONEX dependency injection container. The validator is registered as
-    a factory, allowing lazy instantiation when first resolved.
+    an instance after being created with the container reference.
 
     Thread Safety:
         Registration is typically done at startup before the container is frozen.
@@ -53,17 +53,17 @@ class RegistryInfraArchitectureValidator:
         )
 
         container = ModelONEXContainer()
-        RegistryInfraArchitectureValidator.register(container)
+        await RegistryInfraArchitectureValidator.register(container)
         ```
     """
 
     @staticmethod
-    def register(container: ModelONEXContainer) -> None:
+    async def register(container: ModelONEXContainer) -> None:
         """Register architecture validator with container.
 
         Registers the NodeArchitectureValidator as a service in the ONEX
-        dependency injection container. The validator is registered with
-        a factory function that creates a new instance on demand.
+        dependency injection container. The validator is created immediately
+        and registered as a singleton instance.
 
         Args:
             container: The DI container to register with.
@@ -77,22 +77,29 @@ class RegistryInfraArchitectureValidator:
         Example:
             ```python
             container = ModelONEXContainer()
-            RegistryInfraArchitectureValidator.register(container)
+            await RegistryInfraArchitectureValidator.register(container)
 
             # Resolve when needed
-            validator = container.get_service(NodeArchitectureValidator)
+            validator = await container.service_registry.resolve_service(
+                NodeArchitectureValidator
+            )
             result = await validator.compute(request)
             ```
         """
+        from omnibase_core.enums import EnumInjectionScope
+
         # Check if service_registry is available
         if container.service_registry is None:
             # Container doesn't have full DI support - skip registration
             # This allows the code to work with minimal container configurations
             return
 
-        container.service_registry.register(
-            NodeArchitectureValidator,
-            lambda c: NodeArchitectureValidator(c),
+        # Create instance and register (factory registration not supported in v1.0)
+        validator_instance = NodeArchitectureValidator(container)
+        await container.service_registry.register_instance(
+            interface=NodeArchitectureValidator,
+            instance=validator_instance,
+            scope=EnumInjectionScope.GLOBAL,
         )
 
 

omnibase_infra/nodes/effects/contract.yaml

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

omnibase_infra/nodes/node_registration_orchestrator/contract.yaml

@@ -36,6 +36,13 @@ node_version: "1.0.0"
 name: "node_registration_orchestrator"
 node_type: "ORCHESTRATOR_GENERIC"
 description: "Registration workflow orchestrator that coordinates node lifecycle by calling reducer for intents and effect for execution."
+# MCP (Model Context Protocol) Configuration
+# Exposes this orchestrator as an AI-invocable tool via MCP server
+mcp:
+  expose: true
+  tool_name: "register_node"
+  description: "Register a new ONEX node with the cluster. Handles Consul service registration and PostgreSQL metadata storage. Returns registration status and assigned service ID."
+  timeout_seconds: 30
 input_model:
   name: "ModelOrchestratorInput"
   module: "omnibase_infra.nodes.node_registration_orchestrator.models"

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/plugin.py

@@ -515,7 +515,7 @@ class PluginRegistration:
             # Deferred import: Only load HandlerConsul when Consul is configured
             from omnibase_infra.handlers import HandlerConsul
 
-            self._consul_handler = HandlerConsul()
+            self._consul_handler = HandlerConsul(config.container)
             await self._consul_handler.initialize(
                 {"host": consul_host, "port": consul_port}
             )

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 ProtocolContainerAware directly with:
     - handler_id, category, message_types, node_kind properties
     - handle(envelope) -> ModelHandlerOutput signature
 
@@ -88,11 +88,12 @@ 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
 from omnibase_infra.errors import ModelInfraErrorContext, ProtocolConfigurationError
+from omnibase_infra.protocols import ProtocolContainerAware
 from omnibase_infra.runtime.contract_loaders import (
     load_handler_class_info_from_contract,
 )
@@ -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 ProtocolContainerAware via duck typing.
 
     Uses duck typing to verify the handler has the required properties and
-    methods for ProtocolMessageHandler compliance. Per ONEX conventions,
+    methods for ProtocolContainerAware compliance. Per ONEX conventions,
     protocol compliance is verified via structural typing rather than
     isinstance checks.
 
-    Protocol Requirements (ProtocolMessageHandler):
+    Protocol Requirements (ProtocolContainerAware):
         - 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 ProtocolContainerAware
             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 ProtocolContainerAware. "
                     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/timeout_coordinator.py

@@ -203,8 +203,9 @@ class TimeoutCoordinator:
 
     Usage in orchestrator:
         >>> # Wire dependencies
-        >>> timeout_query = ServiceTimeoutScanner(projection_reader)
+        >>> timeout_query = ServiceTimeoutScanner(container, projection_reader)
         >>> timeout_emission = ServiceTimeoutEmitter(
+        ...     container=container,
         ...     timeout_query=timeout_query,
         ...     event_bus=event_bus,
         ...     projector=projector,
@@ -235,8 +236,8 @@ class TimeoutCoordinator:
 
         Example:
             >>> reader = ProjectionReaderRegistration(pool)
-            >>> query = ServiceTimeoutScanner(reader)
-            >>> emission = ServiceTimeoutEmitter(query, event_bus, projector)
+            >>> query = ServiceTimeoutScanner(container, reader)
+            >>> emission = ServiceTimeoutEmitter(container, query, event_bus, projector)
             >>> coordinator = TimeoutCoordinator(query, emission)
         """
         self._timeout_query = timeout_query

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/node.py

@@ -44,7 +44,10 @@ Pluggable Backends:
 
     # Create container and register handler
     container = ModelONEXContainer()
-    handler = HandlerRegistrationStoragePostgres(dsn="postgresql://...")
+    handler = HandlerRegistrationStoragePostgres(
+        container=container,
+        dsn="postgresql://...",
+    )
     RegistryInfraRegistrationStorage.register(container)
     RegistryInfraRegistrationStorage.register_handler(container, handler)