ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/schemas/platform.py

@@ -0,0 +1,149 @@
+"""
+Platform requirements and security capability schemas.
+
+These schemas define what security/platform features an adapter or tool requires
+to operate. This enables platform-bound services that require proof of possession,
+device attestation, or specific hardware security features.
+"""
+
+from enum import Enum
+from typing import List, Optional, Set
+
+from pydantic import BaseModel, Field
+
+
+class PlatformRequirement(str, Enum):
+    """Platform security requirements for adapters and tools.
+
+    These represent proof-of-possession and device attestation requirements
+    that cannot be satisfied without specific platform capabilities.
+    """
+
+    # Mobile device attestation (proof of real device, not emulator)
+    ANDROID_PLAY_INTEGRITY = "android_play_integrity"  # Google Play Integrity API
+    IOS_APP_ATTEST = "ios_app_attest"  # Apple App Attest
+    IOS_DEVICE_CHECK = "ios_device_check"  # Apple DeviceCheck
+
+    # Token binding / Proof of Possession
+    DPOP = "dpop"  # Demonstrating Proof of Possession (RFC 9449)
+    MTLS = "mtls"  # Mutual TLS with client certificate
+
+    # Hardware security
+    TPM = "tpm"  # Trusted Platform Module
+    HSM = "hsm"  # Hardware Security Module
+    SECURE_ENCLAVE = "secure_enclave"  # Apple Secure Enclave / Android StrongBox
+    ANDROID_KEYSTORE = "android_keystore"  # Android Keystore (hardware-backed)
+
+    # Authentication requirements
+    GOOGLE_NATIVE_AUTH = "google_native_auth"  # Native Google Sign-In (not web OAuth)
+    APPLE_NATIVE_AUTH = "apple_native_auth"  # Native Apple Sign-In
+
+    # Network requirements
+    CIRIS_PROXY = "ciris_proxy"  # Requires routing through CIRIS proxy
+
+
+class PlatformCapabilities(BaseModel):
+    """Current platform capabilities available at runtime.
+
+    This is populated by platform detection at startup and used to check
+    if platform requirements can be satisfied.
+    """
+
+    platform: str = Field(..., description="Platform identifier (android, ios, linux, windows, macos)")
+    capabilities: Set[PlatformRequirement] = Field(
+        default_factory=set,
+        description="Set of platform requirements this runtime can satisfy",
+    )
+
+    # Device attestation state
+    play_integrity_available: bool = Field(False, description="Google Play Integrity API available")
+    app_attest_available: bool = Field(False, description="Apple App Attest available")
+
+    # Hardware security state
+    hardware_keystore_available: bool = Field(False, description="Hardware-backed keystore available")
+    tpm_available: bool = Field(False, description="TPM available")
+
+    # Authentication state
+    google_native_auth_available: bool = Field(False, description="Native Google Sign-In available")
+    apple_native_auth_available: bool = Field(False, description="Native Apple Sign-In available")
+
+    # Token state
+    has_valid_device_token: bool = Field(False, description="Has valid device-bound token")
+    token_binding_method: Optional[str] = Field(None, description="How token is bound (play_integrity, dpop, etc.)")
+
+    def satisfies(self, requirements: List[PlatformRequirement]) -> bool:
+        """Check if this platform satisfies all given requirements.
+
+        Args:
+            requirements: List of requirements to check
+
+        Returns:
+            True if all requirements are satisfied
+        """
+        if not requirements:
+            return True
+        return all(req in self.capabilities for req in requirements)
+
+    def missing_requirements(self, requirements: List[PlatformRequirement]) -> List[PlatformRequirement]:
+        """Get list of requirements that cannot be satisfied.
+
+        Args:
+            requirements: List of requirements to check
+
+        Returns:
+            List of unsatisfied requirements
+        """
+        return [req for req in requirements if req not in self.capabilities]
+
+
+class PlatformRequirementSet(BaseModel):
+    """A set of platform requirements with optional alternatives.
+
+    Supports expressing requirements like:
+    "Requires (Android Play Integrity OR iOS App Attest) AND Google Native Auth"
+    """
+
+    # All of these must be satisfied (AND)
+    required: List[PlatformRequirement] = Field(
+        default_factory=list,
+        description="All of these requirements must be satisfied",
+    )
+
+    # At least one of these must be satisfied (OR) - for alternatives
+    one_of: List[List[PlatformRequirement]] = Field(
+        default_factory=list,
+        description="For each inner list, at least one requirement must be satisfied",
+    )
+
+    # Human-readable explanation of why these requirements exist
+    rationale: Optional[str] = Field(
+        None,
+        description="Why these requirements exist (shown to user if not satisfied)",
+    )
+
+    def is_satisfied_by(self, capabilities: PlatformCapabilities) -> bool:
+        """Check if capabilities satisfy this requirement set.
+
+        Args:
+            capabilities: Current platform capabilities
+
+        Returns:
+            True if all requirements are satisfied
+        """
+        # Check all required
+        if not capabilities.satisfies(self.required):
+            return False
+
+        # Check one_of groups (each group needs at least one satisfied)
+        for group in self.one_of:
+            if not any(req in capabilities.capabilities for req in group):
+                return False
+
+        return True
+
+
+__all__ = [
+    "PlatformRequirement",
+    "PlatformCapabilities",
+    "PlatformRequirementSet",
+]

ciris_engine/schemas/processors/__init__.py

@@ -0,0 +1,26 @@
+"""Package initialization."""
+
+from .core import (
+    ConscienceApplicationResult,
+    DMAResults,
+    ProcessedThoughtResult,
+    ProcessingError,
+    ThoughtProcessingMetrics,
+)
+from .error import ErrorContext, ErrorHandlingResult, ErrorSeverity
+from .error import ProcessingError as ProcessorError
+from .error import ProcessorConfig
+
+__all__ = [
+    "DMAResults",
+    "ConscienceApplicationResult",
+    "ProcessedThoughtResult",
+    "ThoughtProcessingMetrics",
+    "ProcessingError",
+    # Error handling schemas
+    "ErrorSeverity",
+    "ErrorContext",
+    "ProcessorError",
+    "ErrorHandlingResult",
+    "ProcessorConfig",
+]

ciris_engine/schemas/processors/base.py

@@ -0,0 +1,130 @@
+"""
+Schemas for base processor operations.
+
+These replace all Dict[str, Any] usage in base_processor.py.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProcessorSpecificMetrics(BaseModel):
+    """Processor-specific metrics that extend base metrics."""
+
+    thoughts_generated: int = Field(0, description="Number of thoughts generated")
+    actions_dispatched: int = Field(0, description="Number of actions dispatched")
+    memories_created: int = Field(0, description="Number of memories created")
+    state_transitions: int = Field(0, description="Number of state transitions")
+    average_response_time_ms: Optional[float] = Field(None, description="Average response time")
+    llm_tokens_used: int = Field(0, description="Total LLM tokens consumed")
+    cache_hits: int = Field(0, description="Number of cache hits")
+    cache_misses: int = Field(0, description="Number of cache misses")
+    custom_counters: Dict[str, int] = Field(default_factory=dict, description="Custom counter metrics")
+    custom_gauges: Dict[str, float] = Field(default_factory=dict, description="Custom gauge metrics")
+
+    model_config = ConfigDict(extra="forbid")  # Strict validation for metrics
+
+
+class ProcessorMetrics(BaseModel):
+    """Metrics tracked by processors."""
+
+    start_time: Optional[datetime] = Field(None, description="When processing started")
+    end_time: Optional[datetime] = Field(None, description="When processing ended")
+    items_processed: int = Field(0, description="Number of items processed")
+    errors: int = Field(0, description="Number of errors encountered")
+    rounds_completed: int = Field(0, description="Number of processing rounds completed")
+
+    # Additional metrics can be added by specific processors
+    additional_metrics: ProcessorSpecificMetrics = Field(
+        default_factory=ProcessorSpecificMetrics, description="Processor-specific metrics"
+    )
+
+
+class ProcessorServices(BaseModel):
+    """Services available to processors.
+
+    This schema replaces Dict[str, Any] for service dependencies.
+    All services are optional as different processors need different services.
+
+    Type safety: Processors must cast services to their expected types when
+    accessing them. This ensures mypy strictness while maintaining Pydantic's
+    runtime flexibility with arbitrary_types_allowed.
+    """
+
+    # Core services (REQUIRED for most processors)
+    time_service: Any = Field(None, description="Time service (TimeServiceProtocol)")
+    resource_monitor: Any = Field(None, description="Resource monitor service")
+
+    # Communication services
+    discord_service: Any = Field(None, description="Discord service if available")
+    communication_bus: Any = Field(None, description="Communication bus for multi-adapter support")
+
+    # Storage services
+    memory_service: Any = Field(None, description="Memory service")
+    audit_service: Any = Field(None, description="Audit service")
+    telemetry_service: Any = Field(None, description="Telemetry service")
+
+    # Additional services used by specialized processors
+    service_registry: Any = Field(None, description="Service registry for dynamic service lookup")
+    identity_manager: Any = Field(None, description="Agent identity manager")
+    secrets_service: Any = Field(None, description="Secrets management service")
+    graphql_provider: Any = Field(None, description="GraphQL provider for database access")
+    app_config: Any = Field(None, description="Application configuration accessor")
+    runtime: Any = Field(None, description="Runtime control interface")
+    llm_service: Any = Field(None, description="LLM service for AI operations")
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class AdapterChannelContext(BaseModel):
+    """Context information for a specific channel from an adapter's perspective.
+
+    This is the lightweight schema used by adapters to pass channel information
+    to the system. For the comprehensive system-internal channel context, see
+    ciris_engine.schemas.runtime.system_context.ChannelContext.
+    """
+
+    channel_id: str = Field(..., description="Channel identifier")
+    channel_type: str = Field(..., description="Type of channel (discord, api, cli)")
+    adapter_name: str = Field(..., description="Name of the adapter")
+    user_id: Optional[str] = Field(None, description="User ID if applicable")
+    guild_id: Optional[str] = Field(None, description="Guild/server ID if applicable")
+    thread_id: Optional[str] = Field(None, description="Thread ID if in a thread")
+    permissions: Dict[str, bool] = Field(default_factory=dict, description="Channel permissions")
+    metadata: Dict[str, str] = Field(default_factory=dict, description="Additional channel metadata")
+
+    model_config = ConfigDict(extra="allow")  # Allow adapter-specific fields
+
+
+class ProcessorContext(BaseModel):
+    """Context for processor operations."""
+
+    processor_name: str = Field(..., description="Name of the processor")
+    current_state: str = Field(..., description="Current agent state")
+    round_number: int = Field(..., description="Current round number")
+    channel_context: Optional[AdapterChannelContext] = Field(None, description="Channel context if available")
+    task_context: Optional[str] = Field(None, description="Current task being processed")
+    memory_context: Optional[str] = Field(None, description="Relevant memory context")
+
+
+class MetricsUpdate(BaseModel):
+    """Update to processor metrics."""
+
+    items_processed: Optional[int] = Field(None, description="Items processed increment")
+    errors: Optional[int] = Field(None, description="Errors increment")
+    rounds_completed: Optional[int] = Field(None, description="Rounds completed increment")
+
+    # Specific metric updates
+    thoughts_generated: Optional[int] = Field(None, description="Thoughts generated increment")
+    actions_dispatched: Optional[int] = Field(None, description="Actions dispatched increment")
+    memories_created: Optional[int] = Field(None, description="Memories created increment")
+    state_transitions: Optional[int] = Field(None, description="State transitions increment")
+    llm_tokens_used: Optional[int] = Field(None, description="LLM tokens used increment")
+    cache_hits: Optional[int] = Field(None, description="Cache hits increment")
+    cache_misses: Optional[int] = Field(None, description="Cache misses increment")
+
+    # Custom metric updates
+    custom_counters: Dict[str, int] = Field(default_factory=dict, description="Custom counter increments")
+    custom_gauges: Dict[str, float] = Field(default_factory=dict, description="Custom gauge updates")

ciris_engine/schemas/processors/cognitive.py

@@ -0,0 +1,77 @@
+"""
+Cognitive state schemas for contract-driven architecture.
+
+Typed states for each of the 6 cognitive phases.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WakeupState(BaseModel):
+    """State during WAKEUP phase."""
+
+    identity_confirmed: bool = Field(False, description="Identity verification status")
+    integrity_validated: bool = Field(False, description="System integrity check status")
+    resilience_evaluated: bool = Field(False, description="Resilience assessment status")
+    incompleteness_accepted: bool = Field(False, description="Incompleteness acknowledgment status")
+    gratitude_expressed: bool = Field(False, description="Gratitude expression status")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class WorkState(BaseModel):
+    """State during WORK phase."""
+
+    active_tasks: int = Field(0, ge=0, description="Number of active tasks")
+    completed_tasks: int = Field(0, ge=0, description="Number of completed tasks")
+    pending_thoughts: int = Field(0, ge=0, description="Number of pending thoughts")
+    last_activity: datetime = Field(..., description="Timestamp of last activity")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class PlayState(BaseModel):
+    """State during PLAY phase."""
+
+    creativity_level: float = Field(0.0, ge=0.0, le=1.0, description="Creativity level (0.0 to 1.0)")
+    experimental_approaches: List[str] = Field(default_factory=list, description="List of experimental approaches")
+    novel_discoveries: int = Field(0, ge=0, description="Number of novel discoveries")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SolitudeState(BaseModel):
+    """State during SOLITUDE phase."""
+
+    reflection_cycles: int = Field(0, ge=0, description="Number of reflection cycles completed")
+    maintenance_tasks_completed: int = Field(0, ge=0, description="Number of maintenance tasks completed")
+    patterns_identified: List[str] = Field(default_factory=list, description="Patterns identified during reflection")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class DreamState(BaseModel):
+    """State during DREAM phase."""
+
+    memory_consolidation_progress: float = Field(
+        0.0, ge=0.0, le=1.0, description="Memory consolidation progress (0.0 to 1.0)"
+    )
+    patterns_analyzed: int = Field(0, ge=0, description="Number of patterns analyzed")
+    future_plans_generated: int = Field(0, ge=0, description="Number of future plans generated")
+    benchmark_results: Optional[Dict[str, float]] = Field(None, description="Performance benchmark results")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ShutdownState(BaseModel):
+    """State during SHUTDOWN phase."""
+
+    shutdown_requested: bool = Field(False, description="Whether shutdown was requested")
+    shutdown_accepted: bool = Field(False, description="Whether shutdown was accepted")
+    cleanup_completed: bool = Field(False, description="Whether cleanup is completed")
+    final_message: Optional[str] = Field(None, description="Final message before shutdown")
+
+    model_config = ConfigDict(extra="forbid")

ciris_engine/schemas/processors/context.py

@@ -0,0 +1,35 @@
+"""
+Context models for processor operations.
+
+Provides typed models for processor contexts instead of Dict[str, Any].
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ciris_engine.schemas.runtime.models import Thought
+
+
+class ProcessorContext(BaseModel):
+    """Context passed to processor.process_thought_item."""
+
+    origin: str = Field(..., description="Origin of the processing request")
+    prefetched_thought: Optional[Thought] = Field(None, description="Pre-fetched thought object")
+    batch_context: Optional[Any] = Field(None, description="Batch processing context")
+
+    model_config = ConfigDict(extra="allow")
+
+
+class BatchProcessingContext(BaseModel):
+    """Context for batch processing operations."""
+
+    batch_id: str = Field(..., description="Unique batch identifier")
+    batch_size: int = Field(..., description="Number of items in batch")
+    current_index: int = Field(0, description="Current item index in batch")
+    total_processed: int = Field(0, description="Total items processed so far")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+__all__ = ["ProcessorContext", "BatchProcessingContext"]

ciris_engine/schemas/processors/core.py

@@ -0,0 +1,152 @@
+"""
+Processing schemas for thought and DMA evaluation.
+
+Provides type-safe structures for thought processing results.
+"""
+
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ciris_engine.schemas.conscience.core import EpistemicData
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+
+from ..actions.parameters import (
+    DeferParams,
+    ForgetParams,
+    MemorizeParams,
+    ObserveParams,
+    PonderParams,
+    RecallParams,
+    RejectParams,
+    SpeakParams,
+    TaskCompleteParams,
+    ToolParams,
+)
+from ..dma.results import ActionSelectionDMAResult, CSDMAResult, DSDMAResult, EthicalDMAResult
+
+
+class DMAResults(BaseModel):
+    """Container for DMA evaluation results."""
+
+    ethical_pdma: Optional[EthicalDMAResult] = Field(None, description="Ethical evaluation")
+    csdma: Optional[CSDMAResult] = Field(None, description="Common sense evaluation")
+    dsdma: Optional[DSDMAResult] = Field(None, description="Domain-specific evaluation")
+    errors: List[str] = Field(default_factory=list, description="Errors during evaluation")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SingleConscienceCheckResult(BaseModel):
+    """Result from checking a single conscience."""
+
+    skip: bool = Field(False, description="Whether this conscience check should be skipped")
+    passed: bool = Field(True, description="Whether the conscience check passed")
+    reason: Optional[str] = Field(None, description="Reason for failure if not passed")
+    epistemic_data: Optional[EpistemicData] = Field(None, description="Epistemic data from this conscience")
+    replacement_action: Optional[ActionSelectionDMAResult] = Field(
+        None, description="Replacement action if conscience overrides"
+    )
+    thought_depth_triggered: Optional[bool] = Field(None, description="Whether thought depth guardrail was triggered")
+    updated_status_detected: Optional[bool] = Field(None, description="Whether updated status was detected")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ConscienceCheckInternalResult(BaseModel):
+    """Internal result from _run_conscience_checks before creating ConscienceApplicationResult."""
+
+    final_action: ActionSelectionDMAResult = Field(..., description="Final action after all conscience checks")
+    overridden: bool = Field(False, description="Whether action was overridden by a conscience")
+    override_reason: Optional[str] = Field(None, description="Reason for conscience override")
+    epistemic_data: Optional[EpistemicData] = Field(
+        None, description="Aggregated epistemic data from conscience checks"
+    )
+    thought_depth_triggered: Optional[bool] = Field(None, description="Whether the thought depth guardrail triggered")
+    updated_status_detected: Optional[bool] = Field(
+        None, description="Whether the updated status conscience detected changes"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ConscienceApplicationResult(BaseModel):
+    """Result from conscience application."""
+
+    original_action: ActionSelectionDMAResult = Field(..., description="Original action selected")
+    final_action: ActionSelectionDMAResult = Field(..., description="Final action after consciences")
+    overridden: bool = Field(False, description="Whether action was overridden")
+    override_reason: Optional[str] = Field(None, description="Reason for override")
+    epistemic_data: EpistemicData = Field(..., description="Epistemic faculty data from conscience checks (REQUIRED)")
+    thought_depth_triggered: Optional[bool] = Field(
+        None, description="Whether the thought depth guardrail forced an override"
+    )
+    updated_status_detected: Optional[bool] = Field(
+        None, description="Whether the updated status conscience detected new information"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ProcessedThoughtResult(BaseModel):
+    """Result from thought processor containing both action and conscience data."""
+
+    action_result: ActionSelectionDMAResult = Field(..., description="Action selection result")
+    conscience_result: Optional[ConscienceApplicationResult] = Field(None, description="conscience application result")
+
+    @property
+    def selected_action(self) -> HandlerActionType:
+        """Convenience property for compatibility."""
+        return self.action_result.selected_action
+
+    @property
+    def action_parameters(self) -> Union[
+        ObserveParams,
+        SpeakParams,
+        ToolParams,
+        PonderParams,
+        RejectParams,
+        DeferParams,
+        MemorizeParams,
+        RecallParams,
+        ForgetParams,
+        TaskCompleteParams,
+    ]:
+        """Convenience property for compatibility."""
+        return self.action_result.action_parameters
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ThoughtProcessingMetrics(BaseModel):
+    """Metrics for thought processing."""
+
+    processing_time_ms: float = Field(..., description="Total processing time")
+    dma_time_ms: float = Field(..., description="DMA evaluation time")
+    conscience_time_ms: float = Field(..., description="conscience application time")
+    llm_calls: int = Field(..., description="Number of LLM calls")
+    tokens_used: int = Field(..., description="Total tokens consumed")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ProcessingError(BaseModel):
+    """Error during thought processing."""
+
+    error_type: str = Field(..., description="Type of error")
+    error_message: str = Field(..., description="Error message")
+    component: str = Field(..., description="Component that failed")
+    recoverable: bool = Field(..., description="Whether error is recoverable")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+__all__ = [
+    "DMAResults",
+    "SingleConscienceCheckResult",
+    "ConscienceCheckInternalResult",
+    "ConscienceApplicationResult",
+    "ProcessedThoughtResult",
+    "ThoughtProcessingMetrics",
+    "ProcessingError",
+]

ciris_engine/schemas/processors/dma.py

@@ -0,0 +1,105 @@
+"""Schemas for DMA orchestration operations."""
+
+from typing import Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.dma.results import CSDMAResult, DSDMAResult, EthicalDMAResult
+from ciris_engine.schemas.types import ConfigDict
+
+
+class DMAMetadata(BaseModel):
+    """Metadata for DSDMA operations."""
+
+    channel_id: Optional[str] = Field(None, description="Channel ID if available")
+    user_id: Optional[str] = Field(None, description="User ID if available")
+    platform: Optional[str] = Field(None, description="Platform name")
+    session_data: ConfigDict = Field(default_factory=dict, description="Session-specific data")
+    metadata: ConfigDict = Field(default_factory=dict, description="Additional context metadata")
+
+
+class InitialDMAResults(BaseModel):
+    """Results from initial DMA runs - all 3 DMA results are required."""
+
+    ethical_pdma: EthicalDMAResult = Field(..., description="Ethical PDMA result (required)")
+    csdma: CSDMAResult = Field(..., description="CSDMA result (required)")
+    dsdma: DSDMAResult = Field(..., description="DSDMA result (required)")
+
+    # User prompts passed to each DMA (for debugging/transparency)
+    ethical_pdma_prompt: Optional[str] = Field(None, description="User prompt passed to Ethical PDMA")
+    csdma_prompt: Optional[str] = Field(None, description="User prompt passed to CSDMA")
+    dsdma_prompt: Optional[str] = Field(None, description="User prompt passed to DSDMA")
+
+
+class DMAError(BaseModel):
+    """Error from a DMA execution."""
+
+    dma_name: str = Field(..., description="Name of the DMA that failed")
+    error_message: str = Field(..., description="Error message")
+    error_type: str = Field(..., description="Type of error")
+    traceback: Optional[str] = Field(None, description="Full traceback if available")
+
+
+class DMAErrors(BaseModel):
+    """Collection of DMA errors."""
+
+    ethical_pdma: Optional[DMAError] = Field(None, description="Ethical PDMA error")
+    csdma: Optional[DMAError] = Field(None, description="CSDMA error")
+    dsdma: Optional[DMAError] = Field(None, description="DSDMA error")
+
+    def has_errors(self) -> bool:
+        """Check if any errors occurred."""
+        return any([self.ethical_pdma, self.csdma, self.dsdma])
+
+    def get_error_summary(self) -> str:
+        """Get summary of all errors."""
+        errors = []
+        if self.ethical_pdma:
+            errors.append(f"ethical_pdma: {self.ethical_pdma.error_message}")
+        if self.csdma:
+            errors.append(f"csdma: {self.csdma.error_message}")
+        if self.dsdma:
+            errors.append(f"dsdma: {self.dsdma.error_message}")
+        return "; ".join(errors) if errors else "No errors"
+
+
+class ActionSelectionContext(BaseModel):
+    """Context for action selection."""
+
+    thought_id: str = Field(..., description="Thought ID being processed")
+    task_id: str = Field(..., description="Task ID")
+    channel_id: Optional[str] = Field(None, description="Channel ID if available")
+    ethical_pdma_result: EthicalDMAResult = Field(..., description="Ethical evaluation")
+    csdma_result: CSDMAResult = Field(..., description="Common sense evaluation")
+    dsdma_result: Optional[DSDMAResult] = Field(None, description="Domain specific evaluation")
+    metadata: ConfigDict = Field(default_factory=dict, description="Additional context")
+
+
+class CircuitBreakerStatus(BaseModel):
+    """Status of a circuit breaker."""
+
+    name: str = Field(..., description="Circuit breaker name")
+    is_open: bool = Field(..., description="Whether circuit is open (failing)")
+    failure_count: int = Field(0, description="Number of consecutive failures")
+    last_failure: Optional[str] = Field(None, description="Last failure timestamp")
+    next_attempt: Optional[str] = Field(None, description="When circuit will close")
+
+
+class DMAOrchestratorStatus(BaseModel):
+    """Status of the DMA orchestrator."""
+
+    circuit_breakers: Dict[str, CircuitBreakerStatus] = Field(..., description="Circuit breaker states")
+    retry_limit: int = Field(..., description="Retry limit for DMAs")
+    timeout_seconds: float = Field(..., description="Timeout for DMA execution")
+    dsdma_available: bool = Field(..., description="Whether DSDMA is configured")
+
+
+__all__ = [
+    "DMAMetadata",
+    "InitialDMAResults",
+    "DMAError",
+    "DMAErrors",
+    "ActionSelectionContext",
+    "CircuitBreakerStatus",
+    "DMAOrchestratorStatus",
+]