omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/enums/enum_consumer_group_purpose.py

@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Consumer group purpose enumeration.
+
+This module defines the purpose classification for Kafka consumer groups,
+enabling semantic differentiation of consumer behavior and offset policies.
+
+Consumer Group Purpose Categories:
+    - CONSUME: Standard event consumption (default behavior)
+    - INTROSPECTION: Node introspection and discovery operations
+    - REPLAY: Reprocess historical data from earliest offset
+    - AUDIT: Compliance and read-only consumption
+    - BACKFILL: One-shot bounded consumers for populating derived state
+
+The purpose determines consumer group naming conventions and default
+offset reset policies in the Kafka adapter layer.
+
+Thread Safety:
+    All enums in this module are immutable and thread-safe.
+    Enum values can be safely shared across threads without synchronization.
+
+See Also:
+    - ModelKafkaConsumerConfig: Consumer configuration using this enum
+    - docs/decisions/adr-consumer-group-naming.md: Naming conventions
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EnumConsumerGroupPurpose(str, Enum):
+    """Consumer group purpose classification for Kafka consumers.
+
+    Defines the semantic purpose of a consumer group, which influences:
+    - Consumer group naming conventions (suffix added to group ID)
+    - Default offset reset policy (earliest vs latest)
+    - Expected consumption patterns (continuous vs bounded)
+
+    Values:
+        CONSUME: Standard event consumption for normal processing.
+            - Default offset reset: latest
+            - Naming: {base_group_id}-consume
+            - Pattern: Continuous consumption
+
+        INTROSPECTION: Node introspection and service discovery.
+            - Default offset reset: latest
+            - Naming: {base_group_id}-introspection
+            - Pattern: Targeted discovery queries
+
+        REPLAY: Reprocess historical data from the beginning.
+            - Default offset reset: earliest
+            - Naming: {base_group_id}-replay
+            - Pattern: Full topic reprocessing
+
+        AUDIT: Compliance and read-only consumption.
+            - Default offset reset: earliest
+            - Naming: {base_group_id}-audit
+            - Pattern: Full audit trail capture
+
+        BACKFILL: One-shot bounded consumers for derived state.
+            - Default offset reset: earliest
+            - Naming: {base_group_id}-backfill
+            - Pattern: Bounded consumption until caught up
+
+    Example:
+        >>> purpose = EnumConsumerGroupPurpose.REPLAY
+        >>> f"order-processor-{purpose.value}"
+        'order-processor-replay'
+    """
+
+    CONSUME = "consume"
+    """Standard event consumption (default)."""
+
+    INTROSPECTION = "introspection"
+    """Node introspection and discovery."""
+
+    REPLAY = "replay"
+    """Reprocess historical data from earliest offset."""
+
+    AUDIT = "audit"
+    """Compliance/read-only consumption."""
+
+    BACKFILL = "backfill"
+    """One-shot bounded consumers for populating derived state."""
+
+    def __str__(self) -> str:
+        """Return the string value for serialization."""
+        return self.value
+
+
+__all__: list[str] = ["EnumConsumerGroupPurpose"]

omnibase_infra/enums/enum_contract_type.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Contract Type Enumeration for ONEX Nodes.
+
+Defines the valid contract types for ONEX node contracts. Contract types
+correspond to the 4-node architecture (effect, compute, reducer, orchestrator)
+plus an 'unknown' fallback for backfill scenarios where the type cannot be
+determined from capabilities or node metadata.
+
+This enum is distinct from EnumNodeArchetype in that:
+    - EnumNodeArchetype: Execution shape validation (what outputs are allowed)
+    - EnumContractType: Contract metadata (contract.yaml node_type field)
+
+The UNKNOWN value exists specifically for data migration/backfill scenarios
+where historical records may not have a determinable contract type. It is
+NOT a valid type for new node registrations.
+
+Related Tickets:
+    - OMN-1134: Registry Projection Extensions for Capabilities
+
+See Also:
+    - EnumNodeArchetype: Node archetypes for execution shape validation
+    - EnumNodeKind: Core node kind enumeration (omnibase_core)
+"""
+
+from enum import StrEnum
+
+
+class EnumContractType(StrEnum):
+    """Contract type for ONEX nodes.
+
+    Defines the valid contract types used in node contract metadata,
+    registration projections, and capability discovery queries.
+
+    Attributes:
+        EFFECT: External interaction nodes (API calls, DB operations).
+        COMPUTE: Pure data processing and transformation nodes.
+        REDUCER: State management and persistence nodes.
+        ORCHESTRATOR: Workflow coordination nodes.
+        UNKNOWN: Fallback for backfill when type cannot be determined.
+            NOT valid for new node registrations.
+
+    Example:
+        >>> from omnibase_infra.enums import EnumContractType
+        >>> contract_type = EnumContractType.EFFECT
+        >>> contract_type.value
+        'effect'
+        >>> EnumContractType("reducer")
+        <EnumContractType.REDUCER: 'reducer'>
+    """
+
+    EFFECT = "effect"
+    COMPUTE = "compute"
+    REDUCER = "reducer"
+    ORCHESTRATOR = "orchestrator"
+    UNKNOWN = "unknown"
+
+    @classmethod
+    def valid_types(cls) -> tuple["EnumContractType", ...]:
+        """Return valid contract types (excludes UNKNOWN).
+
+        UNKNOWN is a fallback for backfill scenarios and is not a valid
+        type for new node registrations.
+
+        Returns:
+            Tuple of valid EnumContractType values (EFFECT, COMPUTE,
+            REDUCER, ORCHESTRATOR).
+        """
+        return (cls.EFFECT, cls.COMPUTE, cls.REDUCER, cls.ORCHESTRATOR)
+
+    @classmethod
+    def valid_type_values(cls) -> tuple[str, ...]:
+        """Return valid contract type string values (excludes 'unknown').
+
+        Convenience method for validation contexts where string values
+        are needed.
+
+        Returns:
+            Tuple of valid contract type strings.
+        """
+        return tuple(t.value for t in cls.valid_types())
+
+
+__all__ = ["EnumContractType"]

omnibase_infra/enums/enum_dedupe_strategy.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: 2025 OmniNode Team <info@omninode.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""
+Deduplication strategy enum for corpus capture.
+
+Defines how duplicate executions are detected and handled.
+
+.. versionadded:: 0.5.0
+    Added for CorpusCapture (OMN-1203)
+"""
+
+from enum import Enum
+
+
+class EnumDedupeStrategy(str, Enum):
+    """
+    Deduplication strategies for corpus capture.
+
+    When capturing executions, duplicates can be detected and filtered
+    using different strategies based on what constitutes a "duplicate".
+
+    .. versionadded:: 0.5.0
+        Added for CorpusCapture (OMN-1203)
+    """
+
+    NONE = "none"
+    """No deduplication. All executions are captured."""
+
+    INPUT_HASH = "input_hash"
+    """
+    Deduplicate based on input hash.
+
+    Two executions with the same handler and input data are considered
+    duplicates. This is useful for capturing unique test cases without
+    redundant variations.
+    """
+
+    FULL_MANIFEST_HASH = "full_manifest_hash"
+    """
+    Deduplicate based on full manifest hash.
+
+    Only exact duplicates (same handler, input, output, timing, etc.)
+    are filtered. This preserves executions that had different outcomes
+    even with the same input.
+    """

omnibase_infra/enums/enum_dispatch_status.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""
+Dispatch Status Enumeration.
+
+Defines status values for message dispatch operations in the runtime dispatch engine.
+Used to track the outcome of routing and handler execution.
+
+Thread Safety:
+    All enums in this module are immutable and thread-safe.
+    Enum values can be safely shared across threads without synchronization.
+"""
+
+from enum import Enum, unique
+
+
+@unique
+class EnumDispatchStatus(str, Enum):
+    """
+    Status values for dispatch operations.
+
+    Represents the outcome of a message dispatch operation, from initial
+    routing through handler execution and result publishing.
+
+    Values:
+        SUCCESS: Message was successfully routed, handled, and outputs published
+        ROUTED: Message was successfully routed to a dispatcher (not yet executed)
+        NO_DISPATCHER: No dispatcher was registered for the message type/topic
+        HANDLER_ERROR: Dispatcher execution failed with an exception
+        TIMEOUT: Dispatcher execution exceeded the configured timeout
+        INVALID_MESSAGE: Message failed validation before dispatch
+        PUBLISH_FAILED: Dispatcher succeeded but output publishing failed
+        SKIPPED: Message was intentionally skipped (e.g., filtered, deduplicated)
+        INTERNAL_ERROR: Internal error during dispatch result construction
+
+    Example:
+        >>> status = EnumDispatchStatus.SUCCESS
+        >>> status.is_terminal()
+        True
+        >>> EnumDispatchStatus.ROUTED.is_successful()
+        False
+        >>> str(EnumDispatchStatus.HANDLER_ERROR)
+        'handler_error'
+    """
+
+    SUCCESS = "success"
+    """Message was successfully routed, handled, and outputs published."""
+
+    ROUTED = "routed"
+    """Message was successfully routed to a dispatcher (pending execution)."""
+
+    NO_DISPATCHER = "no_dispatcher"
+    """No dispatcher was registered for the message type/topic."""
+
+    HANDLER_ERROR = "handler_error"
+    """Dispatcher execution failed with an exception."""
+
+    TIMEOUT = "timeout"
+    """Dispatcher execution exceeded the configured timeout."""
+
+    INVALID_MESSAGE = "invalid_message"
+    """Message failed validation before dispatch."""
+
+    PUBLISH_FAILED = "publish_failed"
+    """Dispatcher succeeded but output publishing failed."""
+
+    SKIPPED = "skipped"
+    """Message was intentionally skipped (e.g., filtered, deduplicated)."""
+
+    INTERNAL_ERROR = "internal_error"
+    """Internal error during dispatch result construction (e.g., Pydantic ValidationError)."""
+
+    def __str__(self) -> str:
+        """Return the string value for serialization."""
+        return self.value
+
+    def is_terminal(self) -> bool:
+        """
+        Check if this status represents a terminal state.
+
+        Terminal states indicate the dispatch operation has completed
+        (either successfully or with a failure).
+
+        Returns:
+            True if the status represents a terminal state, False otherwise
+
+        Example:
+            >>> EnumDispatchStatus.SUCCESS.is_terminal()
+            True
+            >>> EnumDispatchStatus.ROUTED.is_terminal()
+            False
+        """
+        return self in {
+            EnumDispatchStatus.SUCCESS,
+            EnumDispatchStatus.NO_DISPATCHER,
+            EnumDispatchStatus.HANDLER_ERROR,
+            EnumDispatchStatus.TIMEOUT,
+            EnumDispatchStatus.INVALID_MESSAGE,
+            EnumDispatchStatus.PUBLISH_FAILED,
+            EnumDispatchStatus.SKIPPED,
+            EnumDispatchStatus.INTERNAL_ERROR,
+        }
+
+    def is_successful(self) -> bool:
+        """
+        Check if this status represents a successful dispatch.
+
+        Returns:
+            True only if status is SUCCESS, False otherwise
+
+        Example:
+            >>> EnumDispatchStatus.SUCCESS.is_successful()
+            True
+            >>> EnumDispatchStatus.ROUTED.is_successful()
+            False
+        """
+        return self == EnumDispatchStatus.SUCCESS
+
+    def is_error(self) -> bool:
+        """
+        Check if this status represents an error condition.
+
+        Returns:
+            True if the status represents an error, False otherwise
+
+        Example:
+            >>> EnumDispatchStatus.HANDLER_ERROR.is_error()
+            True
+            >>> EnumDispatchStatus.SUCCESS.is_error()
+            False
+        """
+        return self in {
+            EnumDispatchStatus.NO_DISPATCHER,
+            EnumDispatchStatus.HANDLER_ERROR,
+            EnumDispatchStatus.TIMEOUT,
+            EnumDispatchStatus.INVALID_MESSAGE,
+            EnumDispatchStatus.PUBLISH_FAILED,
+            EnumDispatchStatus.INTERNAL_ERROR,
+        }
+
+    def requires_retry(self) -> bool:
+        """
+        Check if this status indicates the operation should be retried.
+
+        Only transient failures (timeout, publish_failed) should be retried.
+        Permanent failures (no_dispatcher, invalid_message) should not be retried.
+
+        Returns:
+            True if the operation should be retried, False otherwise
+
+        Example:
+            >>> EnumDispatchStatus.TIMEOUT.requires_retry()
+            True
+            >>> EnumDispatchStatus.NO_DISPATCHER.requires_retry()
+            False
+        """
+        return self in {
+            EnumDispatchStatus.TIMEOUT,
+            EnumDispatchStatus.PUBLISH_FAILED,
+        }
+
+    @classmethod
+    def get_description(cls, status: "EnumDispatchStatus") -> str:
+        """
+        Get a human-readable description of the dispatch status.
+
+        Args:
+            status: The dispatch status to describe
+
+        Returns:
+            A human-readable description of the status
+
+        Example:
+            >>> EnumDispatchStatus.get_description(EnumDispatchStatus.SUCCESS)
+            'Message was successfully routed, handled, and outputs published'
+        """
+        descriptions = {
+            cls.SUCCESS: "Message was successfully routed, handled, and outputs published",
+            cls.ROUTED: "Message was successfully routed to a dispatcher (pending execution)",
+            cls.NO_DISPATCHER: "No dispatcher was registered for the message type/topic",
+            cls.HANDLER_ERROR: "Dispatcher execution failed with an exception",
+            cls.TIMEOUT: "Dispatcher execution exceeded the configured timeout",
+            cls.INVALID_MESSAGE: "Message failed validation before dispatch",
+            cls.PUBLISH_FAILED: "Dispatcher succeeded but output publishing failed",
+            cls.SKIPPED: "Message was intentionally skipped",
+            cls.INTERNAL_ERROR: "Internal error during dispatch result construction",
+        }
+        return descriptions.get(status, "Unknown dispatch status")
+
+
+__all__ = ["EnumDispatchStatus"]

omnibase_infra/enums/enum_environment.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Environment enumeration for deployment target classification.
+
+This module defines the deployment environment types used for security policy
+validation and configuration management. Environment-aware security policies
+can enforce different constraints based on the deployment target.
+
+Usage:
+    The EnumEnvironment is used in security policy models to define
+    environment-specific constraints and in configuration to specify
+    the current deployment target.
+
+See Also:
+    - ModelEnvironmentPolicy: Uses this enum for environment-specific constraints
+    - ModelHandlerSecurityPolicy: Handler-declared security requirements
+"""
+
+from enum import Enum
+
+
+class EnumEnvironment(str, Enum):
+    """Deployment environment classification.
+
+    Defines the deployment environments for security policy enforcement
+    and configuration management. Each environment has different security
+    postures and permitted capabilities.
+
+    Attributes:
+        DEVELOPMENT: Local development environment.
+            Most permissive, allows debugging features and relaxed security.
+        STAGING: Pre-production testing environment.
+            Production-like but allows some testing features.
+        PRODUCTION: Live production environment.
+            Most restrictive, enforces all security constraints.
+        CI: Continuous integration environment.
+            Automated testing, may have elevated permissions for test execution.
+    """
+
+    DEVELOPMENT = "development"
+    STAGING = "staging"
+    PRODUCTION = "production"
+    CI = "ci"
+
+
+__all__ = ["EnumEnvironment"]

omnibase_infra/enums/enum_execution_shape_violation.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Execution Shape Violation Enumeration.
+
+Defines the canonical violation types for the ONEX execution shape validator.
+These violations represent constraint breaches in the ONEX 4-node architecture
+that would compromise system integrity or determinism guarantees.
+
+Violation Categories:
+    - Return Type Violations: Handler returning forbidden output types
+    - Direct Publish Violations: Handler bypassing event bus routing
+    - Determinism Violations: Handler accessing non-deterministic resources
+    - Topic Mismatch Violations: Handler subscribed to wrong topic category
+
+Note on PROJECTION Violations:
+    PROJECTION is a valid node output type (EnumNodeOutputType.PROJECTION) that
+    ONLY REDUCERs may produce. It is NOT a message routing category (not in
+    EnumMessageCategory). This distinction is critical:
+
+    - EnumNodeOutputType: Defines what a node CAN produce (includes PROJECTION)
+    - EnumMessageCategory: Defines how messages are ROUTED (excludes PROJECTION)
+
+    Projections represent aggregated state from REDUCER nodes. They are not
+    routed via Kafka topics like EVENTs, COMMANDs, and INTENTs. Violations like
+    ORCHESTRATOR_RETURNS_PROJECTIONS or EFFECT_RETURNS_PROJECTIONS indicate a
+    non-REDUCER node is incorrectly trying to produce aggregated state output.
+
+See Also:
+    - EnumNodeOutputType: Defines valid node output types (includes PROJECTION)
+    - EnumMessageCategory: Defines message categories for routing (excludes PROJECTION)
+    - EnumHandlerType: Defines the 4-node architecture handler types
+"""
+
+from enum import Enum
+
+
+class EnumExecutionShapeViolation(str, Enum):
+    """Execution shape violation types for ONEX architecture compliance.
+
+    These represent constraint violations detected during static analysis
+    of ONEX handlers. Each violation type indicates a specific breach of
+    the 4-node architecture rules.
+
+    Return Type Violations:
+        FORBIDDEN_RETURN_TYPE: Generic violation for handler returning forbidden type.
+            Used as fallback when no specific violation type is mapped.
+        REDUCER_RETURNS_EVENTS: Reducer handlers cannot emit events.
+            Reducers manage state; event emission is an effect operation.
+        ORCHESTRATOR_RETURNS_INTENTS: Orchestrators cannot emit intents.
+            Intents originate from external systems, not orchestration.
+        ORCHESTRATOR_RETURNS_PROJECTIONS: Orchestrators cannot produce projections.
+            PROJECTION is a node output type (EnumNodeOutputType.PROJECTION), NOT a
+            message routing category (EnumMessageCategory). Projections represent
+            aggregated state and are ONLY valid for REDUCER node output types.
+            Orchestrators coordinate workflows and should return COMMANDs or EVENTs.
+        EFFECT_RETURNS_PROJECTIONS: Effect handlers cannot produce projections.
+            PROJECTION is a node output type (EnumNodeOutputType.PROJECTION), NOT a
+            message routing category (EnumMessageCategory). Projections represent
+            aggregated state and are ONLY valid for REDUCER node output types.
+            Effect handlers interact with external systems and should return
+            EVENTs or COMMANDs.
+
+    Operation Violations:
+        HANDLER_DIRECT_PUBLISH: Handler bypasses event bus for direct publish.
+            All message routing must go through the event bus abstraction.
+        REDUCER_ACCESSES_SYSTEM_TIME: Reducer accesses non-deterministic time.
+            Reducers must be deterministic for replay consistency.
+
+    Topic Violations:
+        TOPIC_CATEGORY_MISMATCH: Handler subscribed to wrong topic category.
+            Event handlers should subscribe to event topics, etc.
+
+    Routing Violations:
+        UNMAPPED_MESSAGE_ROUTE: Message type is not registered in routing.
+            All message types must have explicit route registrations.
+
+    Syntax/Parse Violations:
+        SYNTAX_ERROR: File contains invalid Python syntax.
+            File could not be parsed for analysis due to syntax errors.
+    """
+
+    # Return type violations
+    FORBIDDEN_RETURN_TYPE = "forbidden_return_type"
+    REDUCER_RETURNS_EVENTS = "reducer_returns_events"
+    ORCHESTRATOR_RETURNS_INTENTS = "orchestrator_returns_intents"
+    ORCHESTRATOR_RETURNS_PROJECTIONS = "orchestrator_returns_projections"
+    EFFECT_RETURNS_PROJECTIONS = "effect_returns_projections"
+
+    # Operation violations
+    HANDLER_DIRECT_PUBLISH = "handler_direct_publish"
+    REDUCER_ACCESSES_SYSTEM_TIME = "reducer_accesses_system_time"
+
+    # Topic violations
+    TOPIC_CATEGORY_MISMATCH = "topic_category_mismatch"
+
+    # Routing violations
+    UNMAPPED_MESSAGE_ROUTE = "unmapped_message_route"
+
+    # Syntax/parse violations
+    SYNTAX_ERROR = "syntax_error"
+
+
+__all__ = ["EnumExecutionShapeViolation"]

omnibase_infra/enums/enum_handler_error_type.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Error Type Enumeration.
+
+Defines the canonical error types for handler validation and lifecycle management.
+These error types represent failures that can occur during handler registration,
+validation, configuration, and execution within the ONEX infrastructure.
+
+Error Categories:
+    - Contract Errors: YAML parsing and schema validation failures
+    - Validation Errors: Descriptor and constraint validation failures
+    - Configuration Errors: Handler configuration and setup failures
+    - Registration Errors: Handler registration and lifecycle failures
+    - Type Errors: Handler type mismatches and compatibility issues
+    - Security Errors: Security constraint violations
+    - Architecture Errors: ONEX architecture pattern violations
+    - Execution Errors: Runtime execution shape violations
+
+These error types provide structured classification for handler-related failures,
+enabling precise error reporting, debugging, and recovery strategies.
+
+See Also:
+    - EnumExecutionShapeViolation: Specific execution shape violations
+    - EnumHandlerType: Defines the 4-node architecture handler types
+    - ModelHandlerValidationError: Structured error reporting model
+"""
+
+from enum import Enum
+
+
+class EnumHandlerErrorType(str, Enum):
+    """Handler error types for validation and lifecycle management.
+
+    These represent structured error classifications for failures that occur
+    during handler validation, registration, configuration, and execution.
+    Each error type indicates a specific category of failure.
+
+    Contract Errors:
+        CONTRACT_PARSE_ERROR: Contract YAML parsing failed.
+            The handler's contract.yaml file could not be parsed due to
+            invalid YAML syntax or structure.
+        CONTRACT_VALIDATION_ERROR: Contract field validation failed.
+            The parsed contract contains invalid field values or violates
+            schema constraints defined in the ONEX contract specification.
+
+    Discovery Errors:
+        DISCOVERY_ERROR: Handler discovery failed due to infrastructure issues.
+            The handler could not be discovered due to connection failures,
+            timeouts, or other infrastructure problems (e.g., Consul unavailable,
+            network errors). This is distinct from parse/validation errors which
+            occur AFTER the contract is successfully retrieved.
+
+    Validation Errors:
+        DESCRIPTOR_VALIDATION_ERROR: Handler descriptor validation failed.
+            The handler descriptor (metadata, annotations, signature) does not
+            meet ONEX requirements for the declared handler type.
+        SECURITY_VALIDATION_ERROR: Security constraint violated.
+            The handler violates security policies such as introspection
+            restrictions, input validation requirements, or secret handling.
+        ARCHITECTURE_VALIDATION_ERROR: Architecture pattern violated.
+            The handler violates ONEX architectural patterns such as layering,
+            dependency injection, or node archetype responsibilities.
+
+    Execution Errors:
+        EXECUTION_SHAPE_VIOLATION: ONEX execution shape violated.
+            The handler violates execution shape constraints defined by the
+            4-node architecture (e.g., REDUCER returning events, direct publish).
+            See EnumExecutionShapeViolation for specific violation types.
+
+    Configuration Errors:
+        CONFIGURATION_ERROR: Handler configuration invalid.
+            The handler's configuration (environment variables, service endpoints,
+            container dependencies) is invalid or incomplete.
+
+    Registration Errors:
+        REGISTRATION_ERROR: Handler registration failed.
+            The handler could not be registered with the handler registry due to
+            duplicate registration, missing dependencies, or lifecycle failures.
+
+    Type Errors:
+        TYPE_MISMATCH_ERROR: Handler type doesn't match expected.
+            The handler's declared type (EFFECT, COMPUTE, REDUCER, ORCHESTRATOR)
+            does not match the contract specification or runtime behavior.
+    """
+
+    # Contract errors
+    CONTRACT_PARSE_ERROR = "contract_parse_error"
+    CONTRACT_VALIDATION_ERROR = "contract_validation_error"
+
+    # Discovery errors
+    DISCOVERY_ERROR = "discovery_error"
+
+    # Validation errors
+    DESCRIPTOR_VALIDATION_ERROR = "descriptor_validation_error"
+    SECURITY_VALIDATION_ERROR = "security_validation_error"
+    ARCHITECTURE_VALIDATION_ERROR = "architecture_validation_error"
+
+    # Execution errors
+    EXECUTION_SHAPE_VIOLATION = "execution_shape_violation"
+
+    # Configuration errors
+    CONFIGURATION_ERROR = "configuration_error"
+
+    # Registration errors
+    REGISTRATION_ERROR = "registration_error"
+
+    # Type errors
+    TYPE_MISMATCH_ERROR = "type_mismatch_error"
+
+
+__all__ = ["EnumHandlerErrorType"]