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

omnibase_infra/services/service_capability_query.py

@@ -131,10 +131,10 @@ class ServiceCapabilityQuery(MixinAsyncCircuitBreaker):
         Dependency Injection Pattern: This service is a leaf infrastructure
         service that receives its dependencies directly via constructor
         parameters rather than resolving them from a container. Unlike
-        orchestrators that use ``container.resolve()`` to obtain services
-        dynamically, leaf services like this one are instantiated with
-        concrete dependencies (projection_reader, node_selector) and are
-        themselves resolved by higher-level components.
+        orchestrators that use ``container.service_registry.resolve_service()``
+        to obtain services dynamically, leaf services like this one are
+        instantiated with concrete dependencies (projection_reader, node_selector)
+        and are themselves resolved by higher-level components.
     """
 
     def __init__(

omnibase_infra/services/service_health.py

@@ -57,10 +57,11 @@ See Also:
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, cast
 
 from aiohttp import web
 
+from omnibase_core.types import JsonType
 from omnibase_infra.enums import EnumInfraTransportType
 from omnibase_infra.errors import (
     ModelInfraErrorContext,
@@ -859,7 +860,7 @@ class ServiceHealth:
             response = ModelHealthCheckResponse.success(
                 status=status,
                 version=self._version,
-                details=health_details,
+                details=cast("dict[str, JsonType]", health_details),
             )
 
             return web.Response(

omnibase_infra/services/service_timeout_emitter.py

@@ -36,6 +36,8 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+from omnibase_core.container import ModelONEXContainer
+from omnibase_core.models.events.model_event_envelope import ModelEventEnvelope
 from omnibase_infra.enums import EnumInfraTransportType
 from omnibase_infra.errors import ModelInfraErrorContext, ProtocolConfigurationError
 from omnibase_infra.models.projection import ModelRegistrationProjection
@@ -216,6 +218,7 @@ class ServiceTimeoutEmitter:
 
     Usage:
         >>> emitter = ServiceTimeoutEmitter(
+        ...     container=container,
         ...     timeout_query=timeout_scanner,
         ...     event_bus=event_bus,
         ...     projector=projector,
@@ -261,6 +264,7 @@ class ServiceTimeoutEmitter:
 
     def __init__(
         self,
+        container: ModelONEXContainer,
         timeout_query: ServiceTimeoutScanner,
         event_bus: ProtocolEventBus,
         projector: ProjectorShell,
@@ -269,6 +273,7 @@ class ServiceTimeoutEmitter:
         """Initialize with required dependencies.
 
         Args:
+            container: ONEX container for dependency injection.
             timeout_query: Scanner for querying overdue entities.
                 Must be initialized with a ProjectionReaderRegistration.
             event_bus: Event bus for publishing timeout events.
@@ -280,16 +285,18 @@ class ServiceTimeoutEmitter:
 
         Example:
             >>> reader = ProjectionReaderRegistration(pool)
-            >>> timeout_query = ServiceTimeoutScanner(reader)
+            >>> timeout_query = ServiceTimeoutScanner(container, reader)
             >>> bus = EventBusKafka.default()
             >>> projector = projector_loader.load("registration_projector")
             >>> emitter = ServiceTimeoutEmitter(
+            ...     container=container,
             ...     timeout_query=timeout_query,
             ...     event_bus=bus,
             ...     projector=projector,
             ...     config=ModelTimeoutEmissionConfig(environment="dev"),
             ... )
         """
+        self._container = container
         self._timeout_query = timeout_query
         self._event_bus = event_bus
         self._projector = projector
@@ -568,8 +575,13 @@ class ServiceTimeoutEmitter:
             },
         )
 
+        # Wrap event in ModelEventEnvelope for protocol compliance
+        envelope: ModelEventEnvelope[object] = ModelEventEnvelope(
+            payload=event,
+            correlation_id=correlation_id,
+        )
         await self._event_bus.publish_envelope(
-            envelope=event,
+            envelope=envelope,  # type: ignore[arg-type]
             topic=topic,
         )
 
@@ -657,8 +669,13 @@ class ServiceTimeoutEmitter:
             },
         )
 
+        # Wrap event in ModelEventEnvelope for protocol compliance
+        envelope: ModelEventEnvelope[object] = ModelEventEnvelope(
+            payload=event,
+            correlation_id=correlation_id,
+        )
         await self._event_bus.publish_envelope(
-            envelope=event,
+            envelope=envelope,  # type: ignore[arg-type]
             topic=topic,
         )
 

omnibase_infra/services/service_timeout_scanner.py

@@ -31,6 +31,7 @@ from uuid import UUID, uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from omnibase_core.container import ModelONEXContainer
 from omnibase_infra.models.projection import ModelRegistrationProjection
 from omnibase_infra.projectors.projection_reader_registration import (
     ProjectionReaderRegistration,
@@ -126,7 +127,7 @@ class ServiceTimeoutScanner:
 
     Usage:
         >>> reader = ProjectionReaderRegistration(pool)
-        >>> scanner = ServiceTimeoutScanner(reader)
+        >>> scanner = ServiceTimeoutScanner(container, reader)
         >>> result = await scanner.find_overdue_entities(now=tick.now)
         >>>
         >>> for projection in result.ack_timeouts:
@@ -152,12 +153,14 @@ class ServiceTimeoutScanner:
 
     def __init__(
         self,
+        container: ModelONEXContainer,
         projection_reader: ProjectionReaderRegistration,
         batch_size: int | None = None,
     ) -> None:
-        """Initialize with projection reader dependency.
+        """Initialize the timeout scanner service.
 
         Args:
+            container: ONEX container for dependency injection.
             projection_reader: The projection reader for database queries.
                 Must be initialized with an asyncpg connection pool.
             batch_size: Maximum entities to return per query type.
@@ -166,8 +169,9 @@ class ServiceTimeoutScanner:
         Example:
             >>> pool = await asyncpg.create_pool(dsn)
             >>> reader = ProjectionReaderRegistration(pool)
-            >>> scanner = ServiceTimeoutScanner(reader)
+            >>> scanner = ServiceTimeoutScanner(container, reader)
         """
+        self._container = container
         self._reader = projection_reader
         self._batch_size = batch_size or self.DEFAULT_BATCH_SIZE
 

omnibase_infra/services/session/__init__.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Session storage and event consumer services.
+
+This module provides infrastructure for persisting Claude Code session
+snapshots and consuming session events from Kafka.
+
+Moved from omniclaude as part of OMN-1526 architectural cleanup.
+
+Components:
+    - SessionSnapshotStore: PostgreSQL storage for session snapshots
+    - SessionEventConsumer: Kafka consumer for session events
+    - ConfigSessionStorage: Storage configuration
+    - ConfigSessionConsumer: Consumer configuration
+    - ConsumerMetrics: Metrics for consumer observability
+    - EnumCircuitState: Circuit breaker states
+
+Example:
+    >>> from omnibase_infra.services.session import (
+    ...     SessionSnapshotStore,
+    ...     ConfigSessionStorage,
+    ... )
+    >>> from pydantic import SecretStr
+    >>>
+    >>> config = ConfigSessionStorage(postgres_password=SecretStr("secret"))
+    >>> store = SessionSnapshotStore(config)
+    >>> await store.initialize()
+"""
+
+from omnibase_infra.services.session.config_consumer import ConfigSessionConsumer
+from omnibase_infra.services.session.config_store import ConfigSessionStorage
+from omnibase_infra.services.session.consumer import (
+    ConsumerMetrics,
+    EnumCircuitState,
+    SessionEventConsumer,
+)
+from omnibase_infra.services.session.protocol_session_aggregator import (
+    ProtocolSessionAggregator,
+)
+from omnibase_infra.services.session.store import (
+    SessionSnapshotStore,
+    SessionStoreNotInitializedError,
+)
+
+__all__ = [
+    # Storage
+    "SessionSnapshotStore",
+    "SessionStoreNotInitializedError",
+    "ConfigSessionStorage",
+    # Consumer
+    "SessionEventConsumer",
+    "ConfigSessionConsumer",
+    "ConsumerMetrics",
+    "EnumCircuitState",
+    "ProtocolSessionAggregator",
+]

omnibase_infra/services/session/config_consumer.py

@@ -0,0 +1,120 @@
+"""Configuration for session event consumers.
+
+Loads from environment variables with OMNIBASE_INFRA_SESSION_CONSUMER_ prefix.
+
+Moved from omniclaude as part of OMN-1526 architectural cleanup.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from pydantic import Field, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigSessionConsumer(BaseSettings):
+    """Configuration for the Claude session event Kafka consumer.
+
+    Environment variables use the OMNIBASE_INFRA_SESSION_CONSUMER_ prefix.
+    Example: OMNIBASE_INFRA_SESSION_CONSUMER_BOOTSTRAP_SERVERS=kafka.example.com:9092
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="OMNIBASE_INFRA_SESSION_CONSUMER_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # Kafka connection
+    bootstrap_servers: str = Field(
+        default="localhost:9092",
+        description="Kafka bootstrap servers. Set via OMNIBASE_INFRA_SESSION_CONSUMER_BOOTSTRAP_SERVERS env var for production.",
+    )
+    group_id: str = Field(
+        default="omnibase-infra-session-consumer",
+        description="Consumer group ID",
+    )
+
+    # Topics to subscribe
+    topics: list[str] = Field(
+        default=[
+            "dev.omniclaude.session.started.v1",
+            "dev.omniclaude.session.ended.v1",
+            "dev.omniclaude.prompt.submitted.v1",
+            "dev.omniclaude.tool.executed.v1",
+        ],
+        description="Kafka topics to consume",
+    )
+
+    # Consumer behavior
+    auto_offset_reset: str = Field(
+        default="earliest",
+        description="Where to start consuming if no offset exists",
+    )
+    enable_auto_commit: bool = Field(
+        default=False,
+        description="Disable auto-commit for at-least-once delivery",
+    )
+    max_poll_records: int = Field(
+        default=100,
+        ge=1,
+        le=10000,
+        description="Maximum records per poll",
+    )
+
+    # Processing
+    batch_timeout_ms: int = Field(
+        default=5000,
+        ge=100,
+        le=60000,
+        description="Timeout for batch processing in milliseconds",
+    )
+
+    # Circuit breaker
+    circuit_breaker_threshold: int = Field(
+        default=5,
+        ge=1,
+        le=100,
+        description="Failures before circuit opens",
+    )
+    circuit_breaker_timeout_seconds: int = Field(
+        default=60,
+        ge=1,
+        le=3600,
+        description="Time before circuit half-opens",
+    )
+    circuit_breaker_half_open_successes: int = Field(
+        default=1,
+        ge=1,
+        le=10,
+        description="Number of successful requests required to close circuit from half-open state",
+    )
+
+    @model_validator(mode="after")
+    def validate_timing_relationships(self) -> ConfigSessionConsumer:
+        """Validate timing relationships between configuration values.
+
+        Warns if circuit breaker timeout is very short relative to batch processing,
+        which could cause premature circuit opens during normal batch operations.
+
+        Returns:
+            Self if validation passes.
+        """
+        batch_timeout_seconds = self.batch_timeout_ms / 1000
+        min_recommended_circuit_timeout = batch_timeout_seconds * 2
+
+        if self.circuit_breaker_timeout_seconds < min_recommended_circuit_timeout:
+            logger.warning(
+                "Circuit breaker timeout (%ds) is less than 2x batch timeout (%.1fs). "
+                "This may cause premature circuit opens during normal batch processing. "
+                "Recommended minimum: %ds",
+                self.circuit_breaker_timeout_seconds,
+                batch_timeout_seconds,
+                int(min_recommended_circuit_timeout),
+            )
+        return self

omnibase_infra/services/session/config_store.py

@@ -0,0 +1,139 @@
+"""Configuration for session snapshot storage.
+
+Loads from environment variables with OMNIBASE_INFRA_SESSION_STORAGE_ prefix.
+
+Moved from omniclaude as part of OMN-1526 architectural cleanup.
+"""
+
+from __future__ import annotations
+
+from pydantic import Field, SecretStr, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class ConfigSessionStorage(BaseSettings):
+    """Configuration for session snapshot PostgreSQL storage.
+
+    Environment variables use the OMNIBASE_INFRA_SESSION_STORAGE_ prefix.
+    Example: OMNIBASE_INFRA_SESSION_STORAGE_POSTGRES_HOST=192.168.86.200
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="OMNIBASE_INFRA_SESSION_STORAGE_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # PostgreSQL connection
+    postgres_host: str = Field(
+        default="192.168.86.200",
+        description="PostgreSQL host",
+    )
+    postgres_port: int = Field(
+        default=5436,
+        ge=1,
+        le=65535,
+        description="PostgreSQL port",
+    )
+    postgres_database: str = Field(
+        default="omninode_bridge",
+        description="PostgreSQL database name",
+    )
+    postgres_user: str = Field(
+        default="postgres",
+        description="PostgreSQL user",
+    )
+    postgres_password: SecretStr = Field(
+        ...,  # Required
+        description="PostgreSQL password - set via OMNIBASE_INFRA_SESSION_STORAGE_POSTGRES_PASSWORD env var",
+    )
+
+    # Connection pool
+    pool_min_size: int = Field(
+        default=2,
+        ge=1,
+        le=100,
+        description="Minimum connection pool size",
+    )
+    pool_max_size: int = Field(
+        default=10,
+        ge=1,
+        le=100,
+        description="Maximum connection pool size",
+    )
+
+    # Query timeouts
+    query_timeout_seconds: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="Query timeout in seconds",
+    )
+
+    @model_validator(mode="after")
+    def validate_pool_sizes(self) -> ConfigSessionStorage:
+        """Validate that pool_min_size <= pool_max_size.
+
+        Returns:
+            Self if validation passes.
+
+        Raises:
+            ValueError: If pool_min_size > pool_max_size.
+        """
+        if self.pool_min_size > self.pool_max_size:
+            raise ValueError(
+                f"pool_min_size ({self.pool_min_size}) must be <= "
+                f"pool_max_size ({self.pool_max_size})"
+            )
+        return self
+
+    @property
+    def dsn(self) -> str:
+        """Build PostgreSQL DSN from components.
+
+        Returns:
+            PostgreSQL connection string.
+        """
+        password = self.postgres_password.get_secret_value()
+        return (
+            f"postgresql://{self.postgres_user}:{password}"
+            f"@{self.postgres_host}:{self.postgres_port}"
+            f"/{self.postgres_database}"
+        )
+
+    @property
+    def dsn_async(self) -> str:
+        """Build async PostgreSQL DSN for asyncpg.
+
+        Returns:
+            PostgreSQL connection string with postgresql+asyncpg scheme.
+        """
+        password = self.postgres_password.get_secret_value()
+        return (
+            f"postgresql+asyncpg://{self.postgres_user}:{password}"
+            f"@{self.postgres_host}:{self.postgres_port}"
+            f"/{self.postgres_database}"
+        )
+
+    @property
+    def dsn_safe(self) -> str:
+        """Build PostgreSQL DSN with password masked (safe for logging).
+
+        Returns:
+            PostgreSQL connection string with password replaced by ***.
+        """
+        return (
+            f"postgresql://{self.postgres_user}:***"
+            f"@{self.postgres_host}:{self.postgres_port}"
+            f"/{self.postgres_database}"
+        )
+
+    def __repr__(self) -> str:
+        """Safe string representation that doesn't expose credentials.
+
+        Returns:
+            String representation with masked password.
+        """
+        return f"ConfigSessionStorage(dsn={self.dsn_safe!r})"