omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/enums/enum_handler_loader_error.py

@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Loader Error Code Enumeration.
+
+Defines structured error codes for the HandlerPluginLoader system. These codes
+enable precise error classification, debugging, and programmatic error handling
+for handler contract discovery and loading operations.
+
+Error Code Ranges:
+    - 001-009: File-level errors (load_from_contract)
+    - 010-019: Import errors (handler class loading)
+    - 020-029: Directory-level errors (load_from_directory)
+    - 030-039: Pattern errors (discover_and_load)
+    - 040-049: Configuration errors (ambiguous configurations)
+
+Usage:
+    >>> from omnibase_infra.enums import EnumHandlerLoaderError
+    >>> error_code = EnumHandlerLoaderError.FILE_NOT_FOUND
+    >>> print(f"Error: {error_code.value}")
+    Error: HANDLER_LOADER_001
+
+    >>> # Check error code in exception handling
+    >>> try:
+    ...     loader.load_from_contract(path)
+    ... except ProtocolConfigurationError as e:
+    ...     if e.model.context.get("loader_error") == EnumHandlerLoaderError.NOT_A_FILE.value:
+    ...         print("Path exists but is not a file")
+
+See Also:
+    - HandlerPluginLoader: Implementation using these error codes
+    - ProtocolHandlerPluginLoader: Protocol defining error code contracts
+"""
+
+from enum import Enum
+
+
+class EnumHandlerLoaderError(str, Enum):
+    """Error codes for handler plugin loader operations.
+
+    These codes provide structured classification for failures during
+    handler contract discovery, parsing, validation, and class loading.
+
+    File-Level Errors (001-009):
+        FILE_NOT_FOUND: Contract file path does not exist.
+            The specified contract file path does not exist on the filesystem.
+            Verify the path is correct and the file has not been moved/deleted.
+
+        INVALID_YAML_SYNTAX: Contract file contains invalid YAML.
+            The contract file could not be parsed due to YAML syntax errors.
+            Check for proper indentation, quoting, and YAML structure.
+
+        SCHEMA_VALIDATION_FAILED: Contract fails schema validation.
+            The parsed YAML does not conform to the handler contract schema.
+            This includes empty files or files with only comments.
+
+        MISSING_REQUIRED_FIELDS: Contract is missing required fields.
+            Required fields (handler_name, handler_class, handler_type) are missing.
+            Add the missing fields to the contract file.
+
+        FILE_SIZE_EXCEEDED: Contract file exceeds size limit.
+            The contract file exceeds the maximum allowed size (10MB).
+            Contract files should be small configuration files.
+
+        PROTOCOL_NOT_IMPLEMENTED: Handler does not implement protocol.
+            The handler class does not implement the required ProtocolHandler
+            interface (missing required methods like describe, initialize, etc.).
+
+        NOT_A_FILE: Path exists but is not a regular file.
+            The specified path exists but is a directory, symlink, or other
+            non-regular file type. Only regular files can be loaded as contracts.
+
+        FILE_READ_ERROR: Failed to read contract file.
+            An I/O error occurred while reading the contract file contents.
+            Check file permissions and filesystem accessibility.
+
+        FILE_STAT_ERROR: Failed to stat contract file.
+            An I/O error occurred while checking file metadata (size, type).
+            Check file permissions and filesystem accessibility.
+
+    Import Errors (010-019):
+        MODULE_NOT_FOUND: Handler module not found.
+            The module specified in handler_class cannot be found.
+            Verify the module path and ensure it's installed/accessible.
+
+        CLASS_NOT_FOUND: Handler class not found in module.
+            The module exists but does not contain the specified class.
+            Verify the class name matches exactly (case-sensitive).
+
+        IMPORT_ERROR: Import error loading handler module.
+            The module exists but failed to import due to syntax errors,
+            missing dependencies, or circular imports.
+
+        NAMESPACE_NOT_ALLOWED: Handler module namespace not in allowed list.
+            The handler module's namespace (package prefix) is not in the
+            configured allowed_namespaces list. This is a security control to
+            prevent loading handlers from untrusted packages. Add the module's
+            namespace prefix to allowed_namespaces or remove the restriction.
+
+    Directory Errors (020-029):
+        DIRECTORY_NOT_FOUND: Directory does not exist.
+            The specified directory path does not exist on the filesystem.
+
+        PERMISSION_DENIED: Permission denied accessing directory.
+            Insufficient permissions to read the directory contents.
+
+        NOT_A_DIRECTORY: Path exists but is not a directory.
+            The specified path exists but is a file or other non-directory.
+
+    Pattern Errors (030-039):
+        EMPTY_PATTERNS_LIST: Patterns list cannot be empty.
+            The discover_and_load method requires at least one glob pattern.
+
+        INVALID_GLOB_PATTERN: Invalid glob pattern syntax.
+            The provided glob pattern has invalid syntax.
+
+    Configuration Errors (040-049):
+        AMBIGUOUS_CONTRACT_CONFIGURATION: Both handler_contract.yaml and contract.yaml
+            exist in the same directory. This is an ambiguous configuration that could
+            lead to duplicate handler registrations or unexpected behavior. Use only
+            ONE contract file per handler directory to avoid this error.
+    """
+
+    # File-level errors (001-009)
+    FILE_NOT_FOUND = "HANDLER_LOADER_001"
+    INVALID_YAML_SYNTAX = "HANDLER_LOADER_002"
+    SCHEMA_VALIDATION_FAILED = "HANDLER_LOADER_003"
+    MISSING_REQUIRED_FIELDS = "HANDLER_LOADER_004"
+    FILE_SIZE_EXCEEDED = "HANDLER_LOADER_005"
+    PROTOCOL_NOT_IMPLEMENTED = "HANDLER_LOADER_006"
+    NOT_A_FILE = "HANDLER_LOADER_007"
+    FILE_READ_ERROR = "HANDLER_LOADER_008"
+    FILE_STAT_ERROR = "HANDLER_LOADER_009"
+
+    # Import errors (010-019)
+    MODULE_NOT_FOUND = "HANDLER_LOADER_010"
+    CLASS_NOT_FOUND = "HANDLER_LOADER_011"
+    IMPORT_ERROR = "HANDLER_LOADER_012"
+    NAMESPACE_NOT_ALLOWED = "HANDLER_LOADER_013"
+
+    # Directory errors (020-029)
+    DIRECTORY_NOT_FOUND = "HANDLER_LOADER_020"
+    PERMISSION_DENIED = "HANDLER_LOADER_021"
+    NOT_A_DIRECTORY = "HANDLER_LOADER_022"
+
+    # Pattern errors (030-039)
+    EMPTY_PATTERNS_LIST = "HANDLER_LOADER_030"
+    INVALID_GLOB_PATTERN = "HANDLER_LOADER_031"
+
+    # Configuration errors (040-049)
+    AMBIGUOUS_CONTRACT_CONFIGURATION = "HANDLER_LOADER_040"
+
+    @property
+    def is_file_error(self) -> bool:
+        """Check if this is a file-level error (001-009)."""
+        return self.value.startswith("HANDLER_LOADER_00")
+
+    @property
+    def is_import_error(self) -> bool:
+        """Check if this is an import error (010-019)."""
+        return self.value.startswith("HANDLER_LOADER_01")
+
+    @property
+    def is_directory_error(self) -> bool:
+        """Check if this is a directory error (020-029)."""
+        return self.value.startswith("HANDLER_LOADER_02")
+
+    @property
+    def is_pattern_error(self) -> bool:
+        """Check if this is a pattern error (030-039)."""
+        return self.value.startswith("HANDLER_LOADER_03")
+
+    @property
+    def is_configuration_error(self) -> bool:
+        """Check if this is a configuration error (040-049)."""
+        return self.value.startswith("HANDLER_LOADER_04")
+
+
+__all__ = ["EnumHandlerLoaderError"]

omnibase_infra/enums/enum_handler_source_mode.py

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Source Mode Enumeration for Handler Loading Strategy.
+
+Defines the canonical source modes for handler loading in the ONEX runtime.
+Each mode determines where handlers are discovered and loaded from, enabling
+flexible deployment configurations and migration strategies.
+
+Handler loading can operate in four modes:
+    - BOOTSTRAP: Only use hardcoded bootstrap handlers.
+                 Uses the legacy hardcoded handler registry. No YAML contract
+                 discovery. Useful for minimal deployments or testing.
+    - CONTRACT: Only use YAML contract-discovered handlers.
+                All handlers must be defined in contract.yaml files. No
+                hardcoded handlers are loaded. Enables fully declarative
+                handler configuration.
+    - HYBRID: Per-handler resolution with contract precedence.
+              When a handler identity matches both bootstrap and contract,
+              the contract-defined handler wins. Bootstrap handlers serve
+              as fallback for handlers not defined in contracts.
+    - KAFKA_EVENTS: Cache-only Kafka-based contract discovery.
+                    Subscribes to platform-reserved contract topics and
+                    maintains an in-memory cache of discovered handlers.
+                    Does NOT wire business subscriptions dynamically.
+                    For beta: discover + next restart applies model.
+
+The HYBRID mode supports gradual migration from hardcoded to contract-based
+handlers by allowing both sources to coexist with deterministic resolution.
+
+See Also:
+    - EnumHandlerSourceType: Defines validation error source types (different purpose)
+    - HandlerPluginLoader: Uses this enum to determine loading strategy
+    - ModelRuntimeConfig: Configuration model that holds the source mode setting
+    - KafkaContractSource: Implements KAFKA_EVENTS mode (OMN-1654)
+"""
+
+from enum import Enum
+
+
+class EnumHandlerSourceMode(str, Enum):
+    """Handler source modes for handler loading strategy selection.
+
+    These represent the different strategies for discovering and loading
+    handlers at runtime. The mode determines whether handlers come from
+    hardcoded registries, YAML contracts, Kafka events, or a combination.
+
+    Attributes:
+        BOOTSTRAP: Only use hardcoded bootstrap handlers.
+            The runtime loads handlers from the legacy hardcoded registry only.
+            No YAML contract discovery is performed. Use cases:
+            - Minimal deployments without contract infrastructure
+            - Testing with known handler set
+            - Backwards compatibility during migration
+            - Environments where contract files are not available
+        CONTRACT: Only use YAML contract-discovered handlers.
+            All handlers must be defined in contract.yaml files. The hardcoded
+            bootstrap registry is ignored. Use cases:
+            - Fully declarative handler configuration
+            - Dynamic handler deployment via contracts
+            - Environments requiring audit trail of handler changes
+            - Production deployments with contract validation
+        HYBRID: Per-handler resolution with contract precedence.
+            Both bootstrap and contract sources are used. When a handler
+            identity (module + class) matches in both sources, the contract-
+            defined handler takes precedence. Bootstrap handlers serve as
+            fallback for handlers not defined in contracts. Use cases:
+            - Gradual migration from bootstrap to contract
+            - Core handlers in bootstrap, extensions in contracts
+            - Development environments with mixed configurations
+            - A/B testing of handler implementations
+        KAFKA_EVENTS: Cache-only Kafka-based contract discovery.
+            Subscribes to platform-reserved contract topics (baseline-wired)
+            and maintains an in-memory cache of discovered handlers. Does NOT
+            wire business subscriptions dynamically. Use cases:
+            - Distributed contract discovery via event bus
+            - Dynamic contract registration/deregistration via Kafka
+            - Beta: discover + next restart applies model
+    """
+
+    BOOTSTRAP = "bootstrap"
+    CONTRACT = "contract"
+    HYBRID = "hybrid"
+    KAFKA_EVENTS = "kafka_events"
+
+
+__all__ = ["EnumHandlerSourceMode"]

omnibase_infra/enums/enum_handler_source_type.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Source Type Enumeration for Validation Error Identification.
+
+Defines the canonical source types for handler validation errors in the ONEX
+structured validation and error reporting system. Each source type identifies
+where in the validation pipeline an error was detected, enabling precise
+error attribution and targeted remediation.
+
+Handler validation occurs across multiple stages:
+    - CONTRACT: Error from contract.yaml parsing/validation.
+                Issues with YAML structure, required fields, or schema violations.
+    - DESCRIPTOR: Error from handler descriptor validation.
+                  Issues with handler metadata, signatures, or interface compliance.
+    - STATIC_ANALYSIS: Error from AST/static code analysis.
+                       Issues detected by analyzing Python source without execution.
+    - RUNTIME: Error detected during runtime execution.
+               Issues that only manifest when the handler is invoked.
+    - REGISTRATION: Error during handler registration phase.
+                    Issues with handler registration process or registry state.
+    - CONFIGURATION: Error in handler configuration loading.
+                     Issues with configuration values, environment, or dependencies.
+
+See Also:
+    - EnumHandlerType: Defines handler types (EFFECT, COMPUTE, REDUCER, ORCHESTRATOR)
+    - EnumExecutionShapeViolation: Defines validation violation types
+    - ModelHandlerValidationError: Error model that uses this enum for source attribution
+"""
+
+from enum import Enum
+
+
+class EnumHandlerSourceType(str, Enum):
+    """Handler validation error source types for structured error reporting.
+
+    These represent the validation stages where handler errors can be detected.
+    Each source type enables precise error attribution and provides context for
+    debugging and remediation.
+
+    Attributes:
+        CONTRACT: Error from contract.yaml parsing or validation.
+            Indicates issues with the contract definition itself, such as:
+            - Invalid YAML syntax
+            - Missing required fields
+            - Schema validation failures
+            - Invalid handler routing configuration
+        DESCRIPTOR: Error from handler descriptor validation.
+            Indicates issues with handler metadata or interface compliance:
+            - Invalid handler signatures
+            - Missing required methods
+            - Protocol implementation issues
+            - Type annotation problems
+        STATIC_ANALYSIS: Error from AST or static code analysis.
+            Indicates issues detected by analyzing source code without execution:
+            - Forbidden API usage
+            - Invalid import statements
+            - Code structure violations
+            - Purity constraint violations
+        RUNTIME: Error detected during runtime execution.
+            Indicates issues that only manifest when handler is invoked:
+            - Unhandled exceptions
+            - Type mismatches at runtime
+            - Resource exhaustion
+            - Integration failures
+        REGISTRATION: Error during handler registration phase.
+            Indicates issues with the registration process:
+            - Duplicate handler registration
+            - Registry state conflicts
+            - Dependency resolution failures
+            - Handler initialization errors
+        CONFIGURATION: Error in handler configuration loading.
+            Indicates issues with configuration or environment:
+            - Missing environment variables
+            - Invalid configuration values
+            - Dependency injection failures
+            - Service connection issues
+    """
+
+    CONTRACT = "contract"
+    DESCRIPTOR = "descriptor"
+    STATIC_ANALYSIS = "static_analysis"
+    RUNTIME = "runtime"
+    REGISTRATION = "registration"
+    CONFIGURATION = "configuration"
+
+
+__all__ = ["EnumHandlerSourceType"]

omnibase_infra/enums/enum_handler_type.py

@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Type Enumeration - Architectural Role Classification.
+
+Defines the architectural role of handlers in the ONEX system.
+Each handler type drives lifecycle management, protocol selection, and runtime
+invocation pattern. This is orthogonal to behavioral classification (EnumHandlerTypeCategory).
+
+Architectural Role Semantics:
+    - INFRA_HANDLER: Protocol/transport handlers that manage external connections.
+        Examples: HTTP adapters, database connectors, Consul clients, Vault clients.
+        Lifecycle: Connection pooling, health checks, circuit breakers.
+    - NODE_HANDLER: Event processing handlers bound to ONEX nodes.
+        Examples: Effect handlers, orchestrator step handlers.
+        Lifecycle: Node registration, event subscription, capability advertisement.
+    - PROJECTION_HANDLER: Handlers for projection read/write operations.
+        Examples: State projection writers, read model updaters.
+        Lifecycle: Projection versioning, consistency guarantees.
+    - COMPUTE_HANDLER: Pure computation handlers with no side effects.
+        Examples: Validation handlers, transformation handlers.
+        Lifecycle: Stateless, idempotent, cacheable.
+
+Design Principle:
+    Handler descriptors must specify BOTH:
+    1. EnumHandlerType (architectural role - this enum)
+    2. EnumHandlerTypeCategory (behavioral classification)
+
+    This separation enables:
+    - Architectural role: Drives infrastructure binding and lifecycle
+    - Behavioral category: Drives execution shape validation and output constraints
+
+See Also:
+    - EnumHandlerTypeCategory: Behavioral classification (EFFECT, COMPUTE, NONDETERMINISTIC_COMPUTE)
+    - EnumNodeArchetype: Node archetypes for execution shape validation
+    - EnumNodeOutputType: Valid node output types
+    - EnumMessageCategory: Message categories for routing
+    - HANDLER_PROTOCOL_DRIVEN_ARCHITECTURE.md: Full handler architecture documentation
+"""
+
+from enum import Enum
+
+
+class EnumHandlerType(str, Enum):
+    """Handler architectural role - selects interface and lifecycle.
+
+    These represent the architectural classification of handlers in ONEX.
+    Each type drives lifecycle management, protocol selection, and runtime invocation pattern.
+
+    Note: This is orthogonal to EnumHandlerTypeCategory which represents behavioral classification.
+    Both must be specified on handler descriptors.
+
+    Attributes:
+        INFRA_HANDLER: Protocol/transport handlers (HTTP, DB, Consul, Vault).
+            Manages external connections and protocol-specific operations.
+            Lifecycle: Connection pooling, health checks, circuit breakers.
+            Examples: DatabaseAdapter, ConsulClient, VaultClient, HttpGateway.
+        NODE_HANDLER: Event processing handlers bound to nodes.
+            Handles event routing and processing within the ONEX node graph.
+            Lifecycle: Node registration, event subscription, capability advertisement.
+            Examples: RegistrationHandler, IntrospectionHandler, RoutingHandler.
+        PROJECTION_HANDLER: Projection read/write handlers.
+            Manages projection state and read model operations.
+            Lifecycle: Projection versioning, consistency guarantees, snapshot management.
+            Examples: StateProjectionWriter, ReadModelUpdater, SnapshotHandler.
+        COMPUTE_HANDLER: Pure computation handlers.
+            Performs stateless, deterministic transformations.
+            Lifecycle: Stateless, idempotent, cacheable - no external dependencies.
+            Examples: ValidationHandler, TransformationHandler, SerializationHandler.
+    """
+
+    INFRA_HANDLER = "infra_handler"
+    NODE_HANDLER = "node_handler"
+    PROJECTION_HANDLER = "projection_handler"
+    COMPUTE_HANDLER = "compute_handler"
+
+
+__all__ = ["EnumHandlerType"]

omnibase_infra/enums/enum_handler_type_category.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Handler Type Category Enumeration for behavioral classification.
+
+Defines the behavioral classification of handlers for ONEX architecture.
+This enum is orthogonal to EnumHandlerType (architectural role) - both must
+be specified on handler descriptors.
+
+Classification Guide:
+    | Category | Deterministic? | Side Effects? | Examples |
+    |----------|----------------|---------------|----------|
+    | COMPUTE | Yes | No | Validation, transformation, mapping |
+    | EFFECT | N/A | Yes | DB, HTTP, Consul, Vault, Kafka, LLM calls |
+    | NONDETERMINISTIC_COMPUTE | No | No | UUID generation, datetime.now(), random.choice() |
+
+Note: LLM API calls are EFFECT (external I/O), not NONDETERMINISTIC_COMPUTE.
+
+See Also:
+    - EnumHandlerType: Architectural role classification (INFRA_HANDLER, NODE_HANDLER, etc.)
+    - EnumNodeArchetype: Node archetypes for execution shape validation (EFFECT, COMPUTE, etc.)
+    - HANDLER_PROTOCOL_DRIVEN_ARCHITECTURE.md: Full architecture documentation
+
+Note on Naming Consistency:
+    EnumHandlerTypeCategory and EnumNodeArchetype both use EFFECT and COMPUTE values but serve
+    different purposes:
+    - EnumHandlerTypeCategory: Classifies handler BEHAVIOR (side effects, determinism)
+    - EnumNodeArchetype: Classifies node ARCHITECTURE (execution shape validation)
+    The shared terminology reflects that EFFECT handlers are typically bound to EFFECT nodes,
+    and COMPUTE handlers to COMPUTE nodes, but they represent different conceptual axes.
+"""
+
+from enum import Enum
+
+
+class EnumHandlerTypeCategory(str, Enum):
+    """Handler behavioral classification - selects policy envelope.
+
+    Determines how the handler behaves at runtime and what policies apply.
+    Drives: Security rules, determinism guarantees, replay safety, permissions.
+
+    Note: ADAPTER is NOT a category - it's a policy tag (is_adapter: bool) on
+    handler descriptors. Adapters are behaviorally EFFECT but have stricter defaults.
+
+    Attributes:
+        COMPUTE: Pure, deterministic computation. No side effects.
+            Examples: Validation, transformation, mapping, calculations.
+            Safe for replay, caching, and parallel execution.
+        EFFECT: Side-effecting I/O operations. May not be deterministic.
+            Examples: Database operations, HTTP calls, Consul, Vault, Kafka, LLM APIs.
+            Requires idempotency handling for replay safety.
+        NONDETERMINISTIC_COMPUTE: Pure (no I/O) but not deterministic.
+            Examples: UUID generation, datetime.now(), random.choice().
+            No external side effects but results may vary between runs.
+    """
+
+    COMPUTE = "compute"
+    EFFECT = "effect"
+    NONDETERMINISTIC_COMPUTE = "nondeterministic_compute"
+
+
+__all__ = ["EnumHandlerTypeCategory"]

omnibase_infra/enums/enum_infra_transport_type.py

@@ -0,0 +1,73 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Infrastructure Transport Type Enumeration.
+
+Defines the canonical transport types for infrastructure components.
+Used for error context, protocol routing, and transport identification.
+
+Supported transport types:
+    - HTTP: REST API transport
+    - DATABASE: PostgreSQL and other database connections
+    - KAFKA: Kafka message broker
+    - CONSUL: Consul service discovery and KV operations
+    - VAULT: HashiCorp Vault secret management
+    - VALKEY: Valkey (Redis-compatible) cache/messaging
+    - GRPC: gRPC protocol
+    - RUNTIME: Runtime host internal transport
+    - MCP: Model Context Protocol (AI agent tool interface)
+    - FILESYSTEM: Local filesystem operations
+    - INMEMORY: In-memory transport for testing/local development
+    - QDRANT: Qdrant vector database operations
+    - GRAPH: Graph database (Memgraph/Neo4j) operations
+
+Each transport type has a corresponding handler implementation:
+    - HandlerConsul: Service registration, health checks, KV store operations
+    - HandlerVault: Secret retrieval, token management, lease renewal
+    - EventBusKafka: Event publishing/subscription, consumer groups
+    - EventBusInmemory: In-memory event bus for testing and local development
+    - PostgresConnectionManager: Connection pooling, query execution
+    - HandlerMCP: MCP server for exposing ONEX nodes as AI agent tools
+    - HandlerFileSystem: File read/write, directory operations
+"""
+
+from enum import Enum
+
+
+class EnumInfraTransportType(str, Enum):
+    """Infrastructure transport types for ONEX infrastructure components.
+
+    These represent the transport/protocol layer types used in
+    omnibase_infra for external integration.
+
+    Attributes:
+        HTTP: HTTP/REST API transport
+        DATABASE: Database connection transport (PostgreSQL, etc.)
+        KAFKA: Kafka message broker transport
+        CONSUL: Consul discovery transport
+        VAULT: HashiCorp Vault secret transport
+        VALKEY: Valkey (Redis-compatible) cache/message transport
+        GRPC: gRPC protocol transport
+        RUNTIME: Runtime host process internal transport
+        MCP: Model Context Protocol transport for AI agent integration
+        FILESYSTEM: Local filesystem transport
+        INMEMORY: In-memory transport for testing and local development
+        QDRANT: Qdrant vector database transport
+        GRAPH: Graph database (Memgraph/Neo4j) transport
+    """
+
+    HTTP = "http"
+    DATABASE = "db"
+    KAFKA = "kafka"
+    CONSUL = "consul"
+    VAULT = "vault"
+    VALKEY = "valkey"
+    GRPC = "grpc"
+    RUNTIME = "runtime"
+    MCP = "mcp"
+    FILESYSTEM = "filesystem"
+    INMEMORY = "inmemory"
+    QDRANT = "qdrant"
+    GRAPH = "graph"
+
+
+__all__ = ["EnumInfraTransportType"]