omnibase_infra 0.2.2__tar.gz → 0.2.4__tar.gz

{omnibase_infra-0.2.2 → omnibase_infra-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnibase_infra
-Version: 0.2.2
+Version: 0.2.4
 Summary: ONEX Infrastructure - Service integration and database infrastructure tools
 License: MIT
 License-File: LICENSE
@@ -28,8 +28,8 @@ Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
 Requires-Dist: jsonschema (>=4.20.0,<5.0.0)
 Requires-Dist: mcp (>=1.25.0,<2.0.0)
 Requires-Dist: neo4j (>=5.15.0,<6.0.0)
-Requires-Dist: omnibase-core (>=0.9.1,<0.10.0)
-Requires-Dist: omnibase-spi (>=0.5.0,<0.6.0)
+Requires-Dist: omnibase-core (>=0.9.5,<0.10.0)
+Requires-Dist: omnibase-spi (>=0.6.0,<0.7.0)
 Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0)
 Requires-Dist: opentelemetry-instrumentation (>=0.48b0,<0.49)

{omnibase_infra-0.2.2 → omnibase_infra-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "omnibase_infra"
-version = "0.2.2"
+version = "0.2.4"
 description = "ONEX Infrastructure - Service integration and database infrastructure tools"
 authors = ["OmniNode Team <team@omninode.ai>"]
 license = "MIT"
@@ -35,10 +35,10 @@ python = "^3.12"
 #   omnibase-core = { git = "https://github.com/org/omnibase_core.git", rev = "SHA" }
 # Remember to switch back to PyPI versions before merging to main.
 #
-# omnibase-core v0.9.1: Added py.typed for PEP 561 compliance
-omnibase-core = "^0.9.1"
-# omnibase-spi v0.5.0: Protocol updates for omnibase-core 0.8.0 compatibility
-omnibase-spi = "^0.5.0"
+# omnibase-core v0.9.5: Topic suffix validation utilities (OMN-1537)
+omnibase-core = "^0.9.5"
+# omnibase-spi v0.6.0: Protocol updates for omnibase-core 0.9.4 compatibility
+omnibase-spi = "^0.6.0"
 
 # ============================================================================
 # External Dependency Security Guidance
@@ -300,6 +300,8 @@ markers = [
     "runtime: Tests requiring the ONEX runtime container to be running",
     "serial: Tests that must run serially (not in parallel with pytest-xdist) due to resource intensity",
     "heavy: Heavy integration tests requiring real infrastructure (Kafka, PostgreSQL, HTTP servers). Skipped by default, run with RUN_HEAVY_TESTS=1",
+    "real_mcp: Tests using real MCP SDK server and client (requires available port)",
+    "mcp_protocol: Mock-based MCP JSON-RPC protocol tests (not real SDK integration)",
 ]
 addopts = [
     "--strict-markers",

{omnibase_infra-0.2.2 → omnibase_infra-0.2.4}/src/omnibase_infra/__init__.py

@@ -76,7 +76,7 @@ See Also
 - Runtime kernel: omnibase_infra.runtime.service_kernel
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 from . import (
     enums,

{omnibase_infra-0.2.2 → omnibase_infra-0.2.4}/src/omnibase_infra/adapters/adapter_onex_tool_execution.py

@@ -28,6 +28,7 @@ from uuid import UUID, uuid4
 
 import httpx
 
+from omnibase_core.container import ModelONEXContainer
 from omnibase_infra.enums import EnumInfraTransportType
 from omnibase_infra.errors import (
     InfraConnectionError,
@@ -58,11 +59,12 @@ class AdapterONEXToolExecution(MixinAsyncCircuitBreaker):
     - Circuit breaker protection for external HTTP calls
 
     Attributes:
+        _container: ONEX container for dependency injection.
         _http_client: HTTP client for orchestrator dispatch.
         _default_timeout: Default timeout if tool definition doesn't specify one.
 
     Example:
-        >>> adapter = AdapterONEXToolExecution()
+        >>> adapter = AdapterONEXToolExecution(container=container)
         >>> result = await adapter.execute(
         ...     tool=tool_definition,
         ...     arguments={"input_data": "test"},
@@ -74,6 +76,7 @@ class AdapterONEXToolExecution(MixinAsyncCircuitBreaker):
 
     def __init__(
         self,
+        container: ModelONEXContainer,
         http_client: httpx.AsyncClient | None = None,
         default_timeout: float = 30.0,
         circuit_breaker_threshold: int = 5,
@@ -82,12 +85,14 @@ class AdapterONEXToolExecution(MixinAsyncCircuitBreaker):
         """Initialize the execution adapter.
 
         Args:
+            container: ONEX container for dependency injection.
             http_client: Optional HTTP client. If not provided, one will be
                 created during execute() calls.
             default_timeout: Default timeout in seconds for orchestrator calls.
             circuit_breaker_threshold: Max failures before opening circuit (default: 5).
             circuit_breaker_reset_timeout: Seconds before automatic reset (default: 60.0).
         """
+        self._container = container
         self._http_client = http_client
         self._default_timeout = default_timeout
         self._owns_client = http_client is None

omnibase_infra-0.2.4/src/omnibase_infra/capabilities/__init__.py

@@ -0,0 +1,15 @@
+"""Capability extraction and inference for ONEX contracts."""
+
+from omnibase_infra.capabilities.capability_inference_rules import (
+    CapabilityInferenceRules,
+)
+from omnibase_infra.capabilities.contract_capability_extractor import (
+    ContractCapabilityExtractor,
+)
+from omnibase_infra.capabilities.intent_type_extractor import IntentTypeExtractor
+
+__all__ = [
+    "CapabilityInferenceRules",
+    "ContractCapabilityExtractor",
+    "IntentTypeExtractor",
+]

omnibase_infra-0.2.4/src/omnibase_infra/capabilities/capability_inference_rules.py

@@ -0,0 +1,211 @@
+"""Capability inference rules for deriving tags from contract structure.
+
+This module provides deterministic pattern matching to infer capability tags
+from contract fields like intent_types and protocols. Rules are injectable
+via constructor for extensibility while providing sensible defaults.
+"""
+
+from __future__ import annotations
+
+
+class CapabilityInferenceRules:
+    """Code-driven capability inference rules with injectable patterns.
+
+    Deterministic pattern matching for inferring capability_tags from
+    contract structure. All rule mappings are injectable via constructor
+    while providing sensible defaults.
+
+    Args:
+        intent_patterns: Custom/additional intent patterns (merged with defaults).
+        protocol_tags: Custom/additional protocol tags (merged with defaults).
+        node_type_tags: Custom/additional node type tags (merged with defaults).
+
+    Example:
+        # Use defaults
+        rules = CapabilityInferenceRules()
+
+        # Override specific pattern
+        rules = CapabilityInferenceRules(
+            intent_patterns={"redis.": "redis.caching"}
+        )
+
+        # Override existing pattern
+        rules = CapabilityInferenceRules(
+            intent_patterns={"postgres.": "custom.database"}
+        )
+    """
+
+    # Default intent pattern -> capability tag mappings
+    DEFAULT_INTENT_PATTERNS: dict[str, str] = {
+        "postgres.": "postgres.storage",
+        "consul.": "consul.registration",
+        "kafka.": "kafka.messaging",
+        "vault.": "vault.secrets",
+        "valkey.": "valkey.caching",
+        "http.": "http.transport",
+    }
+
+    # Default protocol -> capability tag mappings
+    DEFAULT_PROTOCOL_TAGS: dict[str, str] = {
+        "ProtocolReducer": "state.reducer",
+        "ProtocolDatabaseAdapter": "database.adapter",
+        "ProtocolEventBus": "event.bus",
+        "ProtocolCacheAdapter": "cache.adapter",
+        "ProtocolServiceDiscovery": "service.discovery",
+    }
+
+    # Default node type -> base capability tag
+    DEFAULT_NODE_TYPE_TAGS: dict[str, str] = {
+        "effect": "node.effect",
+        "compute": "node.compute",
+        "reducer": "node.reducer",
+        "orchestrator": "node.orchestrator",
+    }
+
+    def __init__(
+        self,
+        intent_patterns: dict[str, str] | None = None,
+        protocol_tags: dict[str, str] | None = None,
+        node_type_tags: dict[str, str] | None = None,
+    ) -> None:
+        """Initialize with optional custom rules.
+
+        Custom rules are merged with defaults. If a custom rule has the same
+        key as a default rule, the custom rule takes precedence (override).
+
+        Args:
+            intent_patterns: Custom/additional intent patterns (merged with defaults).
+            protocol_tags: Custom/additional protocol tags (merged with defaults).
+            node_type_tags: Custom/additional node type tags (merged with defaults).
+        """
+        self._intent_patterns = {
+            **self.DEFAULT_INTENT_PATTERNS,
+            **(intent_patterns or {}),
+        }
+        self._protocol_tags = {
+            **self.DEFAULT_PROTOCOL_TAGS,
+            **(protocol_tags or {}),
+        }
+        self._node_type_tags = {
+            **self.DEFAULT_NODE_TYPE_TAGS,
+            **(node_type_tags or {}),
+        }
+
+    def infer_from_intent_types(self, intent_types: list[str]) -> list[str]:
+        """Infer capability tags from intent type patterns.
+
+        Pattern matching uses first-match-wins semantics: each intent is matched
+        against patterns in iteration order, and only the FIRST matching pattern
+        is used (early exit via break). This is intentional because intents should
+        belong to a single capability category.
+
+        Example:
+            - "postgres.upsert" matches "postgres." -> "postgres.storage"
+            - "postgres.kafka.hybrid" matches "postgres." only (NOT both postgres and kafka)
+
+        Args:
+            intent_types: List of intent type strings (e.g., ["postgres.upsert", "consul.register"])
+
+        Returns:
+            Sorted list of inferred capability tags (deduplicated)
+        """
+        tags: set[str] = set()
+        for intent in intent_types:
+            if intent is None:  # Skip None values
+                continue
+            for pattern, tag in self._intent_patterns.items():
+                if intent.startswith(pattern):
+                    tags.add(tag)
+                    break
+        return sorted(tags)
+
+    def infer_from_protocols(self, protocols: list[str]) -> list[str]:
+        """Infer capability tags from protocol names.
+
+        Matching behavior:
+            - Exact match: "ProtocolReducer" matches DEFAULT_PROTOCOL_TAGS["ProtocolReducer"]
+            - Suffix match: "MyCustomProtocolReducer" also matches because it ends with "ProtocolReducer"
+            - No match: "ProtocolReducerExtended" does NOT match (doesn't end with known protocol)
+
+        This allows custom-prefixed protocol implementations to inherit base capability tags.
+
+        Warning:
+            Suffix matching can cause unexpected over-matching if your protocol name
+            accidentally ends with a known protocol name. The matching is strict:
+            the protocol name must END with the exact known protocol string.
+
+        Examples:
+            Protocols that MATCH (suffix ends with known protocol)::
+
+                "ProtocolReducer" -> matches "ProtocolReducer" (exact match)
+                "MyCustomProtocolReducer" -> matches "ProtocolReducer" (suffix match)
+                "InfraProtocolDatabaseAdapter" -> matches "ProtocolDatabaseAdapter"
+                "V2ProtocolEventBus" -> matches "ProtocolEventBus"
+
+            Protocols that DO NOT MATCH (suffix has additional characters)::
+
+                "ProtocolReducerV2" -> NO match (ends with "V2", not "ProtocolReducer")
+                "ProtocolReducerExtended" -> NO match (ends with "Extended")
+                "ProtocolReducerExtendedVersion" -> NO match (ends with "Version")
+                "MyReducer" -> NO match (must end with full "ProtocolReducer")
+                "ProtocolReducerImpl" -> NO match (ends with "Impl")
+
+        Args:
+            protocols: List of protocol class names
+
+        Returns:
+            Sorted list of inferred capability tags (deduplicated)
+        """
+        tags: set[str] = set()
+        for protocol in protocols:
+            if protocol is None:  # Skip None values
+                continue
+            # Check exact match
+            if protocol in self._protocol_tags:
+                tags.add(self._protocol_tags[protocol])
+            # Also check if protocol name ends with known suffix
+            for known_protocol, tag in self._protocol_tags.items():
+                if protocol.endswith(known_protocol):
+                    tags.add(tag)
+        return sorted(tags)
+
+    def infer_from_node_type(self, node_type: str) -> list[str]:
+        """Infer base capability tag from node type.
+
+        Args:
+            node_type: Node type string (effect, compute, reducer, orchestrator)
+
+        Returns:
+            List with single node type capability tag, or empty if unknown
+        """
+        normalized = node_type.lower().replace("_generic", "")
+        if normalized in self._node_type_tags:
+            return [self._node_type_tags[normalized]]
+        return []
+
+    def infer_all(
+        self,
+        intent_types: list[str] | None = None,
+        protocols: list[str] | None = None,
+        node_type: str | None = None,
+    ) -> list[str]:
+        """Infer all capability tags from available contract data.
+
+        Args:
+            intent_types: Optional list of intent types
+            protocols: Optional list of protocol names
+            node_type: Optional node type string
+
+        Returns:
+            Sorted, deduplicated list of all inferred capability tags
+        """
+        tags: set[str] = set()
+
+        if intent_types:
+            tags.update(self.infer_from_intent_types(intent_types))
+        if protocols:
+            tags.update(self.infer_from_protocols(protocols))
+        if node_type:
+            tags.update(self.infer_from_node_type(node_type))
+
+        return sorted(tags)

omnibase_infra-0.2.4/src/omnibase_infra/capabilities/contract_capability_extractor.py

@@ -0,0 +1,221 @@
+"""Contract capability extractor for ONEX nodes.
+
+Extracts ModelContractCapabilities from typed contract models.
+No side effects, deterministic output.
+
+OMN-1136: ContractCapabilityExtractor - Main extractor implementation.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from omnibase_core.models.capabilities import ModelContractCapabilities
+from omnibase_core.models.primitives.model_semver import ModelSemVer
+from omnibase_infra.capabilities.capability_inference_rules import (
+    CapabilityInferenceRules,
+)
+from omnibase_infra.capabilities.intent_type_extractor import IntentTypeExtractor
+
+if TYPE_CHECKING:
+    from omnibase_core.models.contracts import (
+        ModelContractBase,
+    )
+
+
+class ContractCapabilityExtractor:
+    """Extracts capabilities from typed contract models.
+
+    Responsibilities:
+    - Read capability-related fields from contract
+    - Apply inference rules to derive additional tags
+    - Union explicit + inferred capabilities
+    - Return deterministic, sorted output
+
+    This extractor is stateless and produces deterministic output
+    for the same contract input.
+
+    Args:
+        rules: Optional custom CapabilityInferenceRules instance. If not provided,
+            uses a default instance with standard rule mappings.
+
+    Example:
+        # Use default rules
+        extractor = ContractCapabilityExtractor()
+
+        # Use custom rules
+        custom_rules = CapabilityInferenceRules(
+            intent_patterns={"redis.": "redis.caching"}
+        )
+        extractor = ContractCapabilityExtractor(rules=custom_rules)
+    """
+
+    def __init__(self, rules: CapabilityInferenceRules | None = None) -> None:
+        """Initialize with optional custom inference rules.
+
+        Args:
+            rules: Custom CapabilityInferenceRules instance. If None, creates
+                a default instance with standard rule mappings.
+        """
+        self._rules = rules if rules is not None else CapabilityInferenceRules()
+        self._intent_extractor = IntentTypeExtractor()
+
+    def extract(self, contract: ModelContractBase) -> ModelContractCapabilities | None:
+        """Extract capabilities from a contract model.
+
+        Args:
+            contract: Typed contract model (Effect, Compute, Reducer, or Orchestrator)
+
+        Returns:
+            ModelContractCapabilities with extracted data, or None if contract is None
+
+        Raises:
+            Any exceptions from extraction propagate (fail-fast behavior).
+        """
+        if contract is None:
+            return None
+
+        # Extract contract type from node_type
+        contract_type = self._extract_contract_type(contract)
+
+        # Extract version
+        contract_version = self._extract_version(contract)
+
+        # Extract intent types (varies by node type)
+        intent_types = self._extract_intent_types(contract)
+
+        # Extract protocols from dependencies
+        protocols = self._extract_protocols(contract)
+
+        # Extract explicit capability tags from contract
+        explicit_tags = self._extract_explicit_tags(contract)
+
+        # Infer additional tags using rules
+        inferred_tags = self._rules.infer_all(
+            intent_types=intent_types,
+            protocols=protocols,
+            node_type=contract_type,
+        )
+
+        # Union explicit + inferred (deterministic), filtering out invalid tags
+        combined_tags = set(explicit_tags) | set(inferred_tags)
+        all_tags = sorted(tag for tag in combined_tags if self._validate_tag(tag))
+
+        return ModelContractCapabilities(
+            contract_type=contract_type,
+            contract_version=contract_version,
+            intent_types=sorted(set(intent_types)),
+            protocols=sorted(set(protocols)),
+            capability_tags=all_tags,
+        )
+
+    def _extract_contract_type(self, contract: ModelContractBase) -> str:
+        """Extract normalized contract type string.
+
+        Raises:
+            ValueError: If contract does not have node_type field.
+        """
+        node_type = getattr(contract, "node_type", None)
+        if node_type is None:
+            raise ValueError("Contract must have node_type field")
+
+        # Handle both enum and string, normalize to lowercase without _GENERIC suffix
+        type_str = node_type.value if hasattr(node_type, "value") else str(node_type)
+        return type_str.lower().replace("_generic", "")
+
+    def _extract_version(self, contract: ModelContractBase) -> ModelSemVer:
+        """Extract contract version.
+
+        Raises:
+            ValueError: If contract_version is missing or not a ModelSemVer instance.
+        """
+        version = getattr(contract, "contract_version", None)
+        if isinstance(version, ModelSemVer):
+            return version
+        raise ValueError(
+            f"Contract must have contract_version as ModelSemVer, "
+            f"got {type(version).__name__ if version is not None else 'None'}"
+        )
+
+    def _extract_intent_types(self, contract: ModelContractBase) -> list[str]:
+        """Extract intent types based on node type.
+
+        Delegates to IntentTypeExtractor which handles extraction from
+        multiple sources based on node type.
+
+        Args:
+            contract: The contract model to extract intent types from.
+
+        Returns:
+            Combined list of intent types from all applicable sources.
+        """
+        return self._intent_extractor.extract_all(contract)
+
+    def _extract_protocols(self, contract: ModelContractBase) -> list[str]:
+        """Extract protocol names from dependencies and interfaces."""
+        protocols: list[str] = []
+
+        # From protocol_interfaces field
+        if hasattr(contract, "protocol_interfaces"):
+            protocol_interfaces = contract.protocol_interfaces
+            if protocol_interfaces:
+                for proto in protocol_interfaces:
+                    if proto is not None:  # Skip None values
+                        protocols.append(proto)
+
+        # From dependencies where type is protocol
+        if hasattr(contract, "dependencies"):
+            dependencies = contract.dependencies
+            if dependencies:
+                for dep in dependencies:
+                    # Check if it's a protocol dependency using is_protocol() method
+                    if hasattr(dep, "is_protocol") and dep.is_protocol():
+                        if hasattr(dep, "name") and dep.name:
+                            protocols.append(dep.name)
+                    # Fallback: check dependency_type directly
+                    elif hasattr(dep, "dependency_type"):
+                        dep_type = dep.dependency_type
+                        type_str = (
+                            dep_type.value
+                            if hasattr(dep_type, "value")
+                            else str(dep_type)
+                        )
+                        if type_str.upper() == "PROTOCOL":
+                            if hasattr(dep, "name") and dep.name:
+                                protocols.append(dep.name)
+
+        return protocols
+
+    def _validate_tag(self, tag: str | None) -> bool:
+        """Validate a tag string.
+
+        Args:
+            tag: Tag string to validate.
+
+        Returns:
+            True if the tag is valid, False otherwise.
+            Invalid tags include: None, empty strings, whitespace-only strings.
+        """
+        if tag is None:
+            return False
+        if not isinstance(tag, str):
+            return False
+        if tag == "":
+            return False
+        if tag.strip() == "":
+            return False
+        return True
+
+    def _extract_explicit_tags(self, contract: ModelContractBase) -> list[str]:
+        """Extract explicitly declared capability tags from contract."""
+        tags: list[str] = []
+
+        # From top-level tags field (all contracts have this)
+        if hasattr(contract, "tags"):
+            contract_tags = contract.tags
+            if contract_tags:
+                for tag in contract_tags:
+                    if self._validate_tag(tag):
+                        tags.append(tag)
+
+        return tags