ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/processors/core/thought_processor/perform_aspdma.py

@@ -0,0 +1,86 @@
+"""
+Action Selection Phase - H3ERE Pipeline Step 3.
+
+ASPDMA (Action Selection Powered Decision Making Algorithm) uses LLM
+to synthesize the 3 parallel DMA results into a specific action selection.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from ciris_engine.logic.dma.exceptions import DMAFailure
+from ciris_engine.logic.processors.core.step_decorators import step_point, streaming_step
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.schemas.actions.parameters import DeferParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+from ciris_engine.schemas.runtime.models import Thought
+from ciris_engine.schemas.services.runtime_control import StepPoint
+
+if TYPE_CHECKING:
+    from ciris_engine.logic.processors.support.dma_orchestrator import DMAOrchestrator
+
+logger = logging.getLogger(__name__)
+
+
+class ActionSelectionPhase:
+    """
+    Phase 3: Action Selection (ASPDMA)
+
+    Uses LLM-powered Action Selection to synthesize the 3 parallel DMA results:
+    - Analyzes all DMA perspectives
+    - Selects optimal action based on comprehensive analysis
+    - Handles Wise Authority deferrals
+
+    Attributes (provided by ThoughtProcessor):
+        dma_orchestrator: DMA orchestration service
+    """
+
+    if TYPE_CHECKING:
+        dma_orchestrator: "DMAOrchestrator"
+
+        async def _fetch_thought(self, thought_id: str, occurrence_id: str = "default") -> Thought | None: ...
+        def _create_deferral_result(self, dma_results: Any, thought: Thought) -> ActionSelectionDMAResult: ...
+        def _get_profile_name(self, thought: Thought) -> str: ...
+
+    @streaming_step(StepPoint.PERFORM_ASPDMA)
+    @step_point(StepPoint.PERFORM_ASPDMA)
+    async def _perform_aspdma_step(
+        self, thought_item: ProcessingQueueItem, thought_context: Any, dma_results: Any
+    ) -> ActionSelectionDMAResult:
+        """Step 3: LLM-powered action selection."""
+        thought = await self._fetch_thought(thought_item.thought_id, thought_item.agent_occurrence_id)
+
+        # Check for WA deferral first
+        if (
+            dma_results
+            and hasattr(dma_results, "should_defer_to_wise_authority")
+            and dma_results.should_defer_to_wise_authority
+        ):
+            return self._create_deferral_result(dma_results, thought)  # type: ignore[arg-type]
+
+        profile_name = self._get_profile_name(thought)  # type: ignore[arg-type]
+        try:
+            action_result = await self.dma_orchestrator.run_action_selection(
+                thought_item=thought_item,
+                actual_thought=thought,  # type: ignore[arg-type]
+                processing_context=thought_context,  # This is the ThoughtContext
+                dma_results=dma_results,
+                profile_name=profile_name,
+            )
+            return action_result
+        except DMAFailure as dma_err:
+            logger.error(
+                f"DMA failure during action selection for {thought_item.thought_id}: {dma_err}",
+                exc_info=True,
+            )
+            defer_params = DeferParams(reason="DMA timeout", context={"error": str(dma_err)}, defer_until=None)
+            return ActionSelectionDMAResult(
+                selected_action=HandlerActionType.DEFER,
+                action_parameters=defer_params,
+                rationale="DMA timeout",
+                raw_llm_response=None,
+                reasoning=None,
+                evaluation_time_ms=None,
+                resource_usage=None,
+            )

ciris_engine/logic/processors/core/thought_processor/perform_dmas.py

@@ -0,0 +1,106 @@
+"""
+DMA Execution Phase - H3ERE Pipeline Step 2.
+
+Responsible for running 3 Decision Making Algorithms (DMAs) to gather
+comprehensive multi-perspective analysis before action selection.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Union
+
+from ciris_engine.logic.dma.exceptions import DMAFailure
+from ciris_engine.logic.processors.core.step_decorators import step_point, streaming_step
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.schemas.actions.parameters import DeferParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+from ciris_engine.schemas.services.runtime_control import StepPoint
+
+if TYPE_CHECKING:
+    from ciris_engine.logic.processors.support.dma_orchestrator import DMAOrchestrator
+    from ciris_engine.protocols.services.graph.telemetry import TelemetryServiceProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class DMAExecutionPhase:
+    """
+    Phase 2: DMA Execution
+
+    Runs 3 Decision Making Algorithms in parallel through the DMA orchestrator:
+    - 3 parallel DMAs for comprehensive analysis
+    - Multi-perspective decision insights
+    - Preparation for action selection
+
+    Attributes (provided by ThoughtProcessor):
+        dma_orchestrator: DMA orchestration service
+        telemetry_service: Optional telemetry service for metrics
+    """
+
+    if TYPE_CHECKING:
+        dma_orchestrator: "DMAOrchestrator"
+        telemetry_service: "TelemetryServiceProtocol | None"
+
+    @streaming_step(StepPoint.PERFORM_DMAS)
+    @step_point(StepPoint.PERFORM_DMAS)
+    async def _perform_dmas_step(
+        self, thought_item: ProcessingQueueItem, thought_context: Any
+    ) -> Union[Any, ActionSelectionDMAResult]:
+        """
+        Step 2: Execute 3 parallel Decision Making Algorithms.
+
+        This decorated method automatically handles:
+        - Real-time streaming of DMA execution progress
+        - Single-step pause/resume capability
+        - Comprehensive error handling with deferral
+        - Telemetry recording for critical failures
+
+        Args:
+            thought_item: The thought being processed
+            thought_context: Context built in previous step
+
+        Returns:
+            DMA results (from 3 parallel algorithms) or ActionSelectionDMAResult (deferral on failure)
+        """
+        try:
+            logger.debug(f"Starting DMA execution for thought {thought_item.thought_id}")
+
+            dma_results = await self.dma_orchestrator.run_initial_dmas(
+                thought_item=thought_item,
+                processing_context=thought_context,
+            )
+
+            logger.info(f"DMA execution completed for thought {thought_item.thought_id}")
+            return dma_results
+
+        except DMAFailure as dma_err:
+            logger.error(
+                f"DMA failure during initial processing for {thought_item.thought_id}: {dma_err}",
+                exc_info=True,
+            )
+
+            # Record telemetry for critical DMA failure
+            if self.telemetry_service:
+                await self.telemetry_service.record_metric(
+                    "dma_failure",
+                    value=1.0,
+                    tags={
+                        "thought_id": thought_item.thought_id,
+                        "error": str(dma_err)[:100],
+                        "path_type": "critical",  # Critical failure
+                        "source_module": "thought_processor",
+                    },
+                )
+
+            # Return deferral result for DMA failures
+            defer_params = DeferParams(reason="DMA timeout", context={"error": str(dma_err)}, defer_until=None)
+
+            return ActionSelectionDMAResult(
+                selected_action=HandlerActionType.DEFER,
+                action_parameters=defer_params,
+                rationale=f"DMA failure: {dma_err}",
+                raw_llm_response=None,
+                reasoning=None,
+                evaluation_time_ms=None,
+                resource_usage=None,
+            )

ciris_engine/logic/processors/core/thought_processor/recursive_processing.py

@@ -0,0 +1,237 @@
+"""
+Recursive Processing Phase - H3ERE Pipeline Step 5.
+
+Handles retry logic when conscience validation fails, including:
+- RECURSIVE_ASPDMA: Retry action selection with guidance
+- RECURSIVE_CONSCIENCE: Re-validate the retried action
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+from ciris_engine.logic.processors.core.step_decorators import step_point, streaming_step
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+from ciris_engine.schemas.services.runtime_control import StepPoint
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+class RecursiveProcessingPhase:
+    """
+    Phase 5: Recursive Processing (Optional)
+
+    Handles retry logic when initial action selection fails conscience validation:
+    - RECURSIVE_ASPDMA: Retry action selection with conscience guidance
+    - RECURSIVE_CONSCIENCE: Re-validate the retry attempt
+    """
+
+    async def _handle_recursive_processing(
+        self,
+        thought_item: Any,
+        thought: Any,
+        thought_context: Any,
+        dma_results: Any,
+        conscience_result: Any,
+        action_result: Any,
+    ) -> Tuple[Optional[Any], Optional[Any]]:
+        """
+        Coordinate recursive processing if conscience validation failed.
+
+        Args:
+            thought_item: The thought being processed
+            thought: Full thought object
+            thought_context: Processing context
+            dma_results: Results from DMA execution
+            conscience_result: Result from conscience validation
+            action_result: Original action selection result
+
+        Returns:
+            Tuple of (final_result, final_conscience_result)
+        """
+        # Check if consciences overrode to PONDER - attempt retry with guidance
+        if (
+            conscience_result
+            and conscience_result.overridden
+            and conscience_result.final_action.selected_action == HandlerActionType.PONDER
+        ):
+            logger.info(f"Conscience override to PONDER for {thought.thought_id}. Attempting retry with guidance.")
+
+            # Try recursive ASPDMA with conscience feedback
+            retry_result = await self._recursive_aspdma_step(
+                thought_item, thought_context, dma_results, conscience_result
+            )
+
+            if retry_result:
+                # Re-apply consciences to the retry result
+                retry_conscience_result = await self._recursive_conscience_step(thought_item, retry_result)
+
+                # Check if retry passed consciences
+                if not retry_conscience_result.overridden:
+                    logger.info(f"Retry action {retry_result.selected_action} passed consciences")
+                    return retry_result, retry_conscience_result
+                else:
+                    logger.info(f"Retry action also failed consciences, proceeding with original")
+
+        return action_result, conscience_result
+
+    @streaming_step(StepPoint.RECURSIVE_ASPDMA)
+    @step_point(StepPoint.RECURSIVE_ASPDMA)
+    async def _recursive_aspdma_step(
+        self, thought_item: ProcessingQueueItem, thought_context: Any, dma_results: Any, override_reason: str
+    ) -> Optional[Any]:
+        """Step 3B: Optional retry action selection after conscience failure."""
+        thought = await self._fetch_thought(thought_item.thought_id, thought_item.agent_occurrence_id)  # type: ignore[attr-defined]
+
+        try:
+            # Re-run action selection with guidance about why previous action failed
+            retry_result = await self._perform_aspdma_with_guidance(
+                thought, thought_context, dma_results, override_reason, max_retries=3
+            )
+            return retry_result
+        except Exception as e:
+            logger.error(f"Recursive ASPDMA failed for thought {thought_item.thought_id}: {e}")
+            return None
+
+    @streaming_step(StepPoint.RECURSIVE_CONSCIENCE)
+    @step_point(StepPoint.RECURSIVE_CONSCIENCE)
+    async def _recursive_conscience_step(self, thought_item: ProcessingQueueItem, retry_result: Any) -> Tuple[Any, Any]:
+        """Step 4B: Optional re-validation if recursive action failed."""
+        if not retry_result:
+            return retry_result, []
+
+        try:
+            recursive_conscience_results = await self.conscience_registry.apply_all_consciences(  # type: ignore[attr-defined]
+                retry_result, thought_item
+            )
+
+            # Check if recursive conscience passed
+            final_conscience_passed = all(result.passed for result in recursive_conscience_results)
+            retry_result.conscience_passed = final_conscience_passed
+
+            return retry_result, recursive_conscience_results
+        except Exception as e:
+            logger.error(f"Recursive conscience execution failed for thought {thought_item.thought_id}: {e}")
+            return retry_result, []
+
+    async def _perform_aspdma_with_guidance(
+        self,
+        thought: Any,
+        thought_context: Any,
+        dma_results: Any,
+        conscience_result: Any,
+        max_retries: int = 3,
+    ) -> Any:
+        """
+        Retry action selection with conscience guidance, with exponential backoff.
+
+        Args:
+            thought: The thought being processed
+            thought_context: Processing context (contains conscience feedback)
+            dma_results: Results from initial DMA execution
+            conscience_result: Conscience result with override_reason explaining why original action failed
+            max_retries: Maximum retry attempts (default: 3)
+
+        Returns:
+            ActionSelectionDMAResult with guidance-informed action selection
+
+        Note:
+            Implements retry logic with cumulative guidance - each retry gets feedback
+            from all previous attempts to improve action selection quality.
+        """
+        from ciris_engine.schemas.conscience.core import ConscienceCheckResult
+        from ciris_engine.schemas.processors.core import ConscienceApplicationResult
+
+        last_error = None
+        retry_history: List[JSONDict] = []
+
+        for attempt in range(max_retries):
+            try:
+                # Extract typed conscience feedback for guidance
+                from ciris_engine.schemas.conscience.core import EpistemicData
+
+                override_reason = ""
+                epistemic_feedback: EpistemicData
+
+                if isinstance(conscience_result, ConscienceApplicationResult):
+                    override_reason = conscience_result.override_reason or "Conscience override occurred"
+                    epistemic_feedback = conscience_result.epistemic_data
+                elif isinstance(conscience_result, dict):
+                    # Legacy dict path - should not happen with typed schemas
+                    override_reason = conscience_result.get("override_reason", "Conscience override occurred")
+                    epistemic_data_dict = conscience_result.get("epistemic_data", {})
+                    # Convert dict to EpistemicData if needed
+                    if isinstance(epistemic_data_dict, EpistemicData):
+                        epistemic_feedback = epistemic_data_dict
+                    else:
+                        # Fallback: create safe default EpistemicData
+                        epistemic_feedback = EpistemicData(
+                            entropy_level=0.5,
+                            coherence_level=0.5,
+                            uncertainty_acknowledged=False,
+                            reasoning_transparency=0.5,
+                        )
+
+                # Build guidance context with typed conscience results + retry history
+                guidance_context = {
+                    "retry_attempt": attempt + 1,
+                    "max_retries": max_retries,
+                    "original_action_failed_because": override_reason,
+                    "conscience_feedback": {
+                        "epistemic_data": epistemic_feedback,
+                        "override_detected": True,
+                    },
+                    "retry_history": retry_history,  # Cumulative feedback from previous attempts
+                }
+
+                # Merge guidance into thought context
+                if hasattr(thought_context, "model_dump"):
+                    enriched_context = thought_context.model_dump()
+                else:
+                    enriched_context = dict(thought_context) if isinstance(thought_context, dict) else {}
+
+                enriched_context["conscience_guidance"] = guidance_context
+
+                # Get profile and re-run action selection with conscience guidance
+                profile_name = self._get_profile_name(thought)  # type: ignore[attr-defined]
+
+                retry_result = await self.dma_orchestrator.run_action_selection(  # type: ignore[attr-defined]
+                    thought_item=thought,
+                    actual_thought=thought,
+                    processing_context=enriched_context,
+                    dma_results=dma_results,
+                    profile_name=profile_name,
+                )
+
+                # Success! Return the result
+                logger.info(
+                    f"ASPDMA retry attempt {attempt + 1}/{max_retries} succeeded for thought {thought.thought_id}"
+                )
+                return retry_result
+
+            except Exception as e:
+                last_error = e
+                logger.warning(
+                    f"ASPDMA retry attempt {attempt + 1}/{max_retries} failed for thought {thought.thought_id}: {e}"
+                )
+
+                # Add this attempt to retry history for next iteration
+                retry_history.append(
+                    {
+                        "attempt": attempt + 1,
+                        "error": str(e),
+                        "error_type": type(e).__name__,
+                    }
+                )
+
+                # If this was the last attempt, raise the error
+                if attempt == max_retries - 1:
+                    logger.error(f"All {max_retries} ASPDMA retry attempts exhausted for thought {thought.thought_id}")
+                    raise last_error
+
+                # Otherwise, continue to next retry
+                continue
+
+        # Should never reach here, but just in case
+        raise RuntimeError(f"ASPDMA retry logic failed unexpectedly for thought {thought.thought_id}")

ciris_engine/logic/processors/core/thought_processor/round_complete.py

@@ -0,0 +1,52 @@
+"""
+Round Complete Phase - H3ERE Pipeline Step 11.
+
+Finalizes the processing round, updates metrics, and prepares for the next round.
+"""
+
+import logging
+from typing import Any, Optional
+
+from ciris_engine.logic.processors.core.step_decorators import step_point, streaming_step
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.schemas.services.runtime_control import StepPoint
+
+logger = logging.getLogger(__name__)
+
+
+class RoundCompletePhase:
+    """
+    Phase 11: Round Complete
+
+    Finalizes the processing round:
+    - Updates round metrics
+    - Cleans up round-specific resources
+    - Prepares for next processing round
+    """
+
+    @streaming_step(StepPoint.ROUND_COMPLETE)
+    @step_point(StepPoint.ROUND_COMPLETE)
+    async def _round_complete_step(self, thought_item: ProcessingQueueItem, final_result: Any) -> Any:
+        """Step 11: Finalize round and update metrics."""
+
+        # Log round completion
+        logger.info(f"Round complete for thought {thought_item.thought_id}")
+
+        # Update round metrics if telemetry service is available
+        if hasattr(self, "telemetry_service") and self.telemetry_service:
+            try:
+                await self.telemetry_service.record_metric(
+                    "round_completed",
+                    value=1.0,
+                    tags={
+                        "thought_id": thought_item.thought_id,
+                        "round_number": str(getattr(self, "current_round_number", 0)),
+                        "final_action": final_result.final_action.selected_action.value if final_result else "none",
+                    },
+                )
+            except Exception as e:
+                logger.error(f"Error recording round completion metric: {e}")
+                # Don't let telemetry errors break the round completion
+
+        # Return the final result unchanged
+        return final_result

ciris_engine/logic/processors/core/thought_processor/start_round.py

@@ -0,0 +1,64 @@
+"""
+Round Initialization Phase - H3ERE Pipeline Step 0.
+
+Responsible for setting up the processing round by transitioning thoughts
+from PENDING to PROCESSING status and preparing them for the H3ERE pipeline.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.processors.core.step_decorators import step_point, streaming_step
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.schemas.runtime.enums import ThoughtStatus
+from ciris_engine.schemas.services.runtime_control import StepPoint
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+class RoundInitializationPhase:
+    """
+    Phase 0: Round Initialization
+
+    Sets up the processing round by:
+    - Moving thoughts from PENDING to PROCESSING status
+    - Creating ProcessingQueueItem objects for pipeline execution
+    - Preparing thoughts for H3ERE pipeline entry
+    """
+
+    @streaming_step(StepPoint.START_ROUND)
+    @step_point(StepPoint.START_ROUND)
+    async def _start_round_step(
+        self, thought_item: ProcessingQueueItem, context: Optional[JSONDict] = None
+    ) -> JSONDict:
+        """Step 0: Initialize processing round and prepare thoughts for H3ERE pipeline."""
+
+        # Get the thought ID and occurrence_id from the queue item
+        thought_id = thought_item.thought_id
+        occurrence_id = thought_item.agent_occurrence_id
+        logger.debug(f"Starting round for thought {thought_id} (occurrence: {occurrence_id})")
+
+        # Fetch the full Thought object from persistence
+        full_thought = persistence.get_thought_by_id(thought_id, occurrence_id)
+        if not full_thought:
+            raise RuntimeError(
+                f"Could not fetch thought {thought_id} (occurrence: {occurrence_id}) from persistence for START_ROUND"
+            )
+
+        # Update thought status from PENDING to PROCESSING
+        persistence.update_thought_status(thought_id, ThoughtStatus.PROCESSING, occurrence_id)
+        logger.info(f"Transitioned thought {thought_id} from PENDING to PROCESSING")
+
+        # The ProcessingQueueItem is already created and passed in, so we just need to
+        # ensure it's ready for the next phase
+
+        return {
+            "round_started": True,
+            "thought_id": thought_id,
+            "status_updated": "PENDING -> PROCESSING",
+            "ready_for_context_gathering": True,
+            "thought_type": full_thought.thought_type.value,
+            "source_task_id": full_thought.source_task_id,
+        }

ciris_engine/logic/processors/exceptions.py

@@ -0,0 +1,59 @@
+"""Custom exception types for thought processor."""
+
+from typing import Any
+
+
+class ProcessorError(Exception):
+    """Base exception for processor errors."""
+
+    def __init__(self, message: str, context: dict[str, Any]):
+        super().__init__(message)
+        self.context = context
+        self.message = message
+
+
+class ActionSelectionRetryFailed(ProcessorError):
+    """Raised when action selection retry fails."""
+
+    def __init__(self, thought_id: str, error_details: str):
+        super().__init__(
+            f"Action selection retry failed for thought {thought_id}",
+            {"thought_id": thought_id, "error_details": error_details},
+        )
+        self.thought_id = thought_id
+
+
+class ConscienceCheckFailed(ProcessorError):
+    """Raised when a conscience check encounters an error."""
+
+    def __init__(self, conscience_name: str, error: Exception):
+        super().__init__(
+            f"Conscience '{conscience_name}' failed: {error}",
+            {"conscience_name": conscience_name, "original_error": str(error)},
+        )
+        self.conscience_name = conscience_name
+        self.original_error = error
+
+
+class DMAExecutionFailed(ProcessorError):
+    """Raised when DMA execution fails."""
+
+    def __init__(self, dma_name: str, error: Exception):
+        super().__init__(
+            f"DMA '{dma_name}' execution failed: {error}",
+            {"dma_name": dma_name, "original_error": str(error)},
+        )
+        self.dma_name = dma_name
+        self.original_error = error
+
+
+class ContextBuildingFailed(ProcessorError):
+    """Raised when context building fails."""
+
+    def __init__(self, thought_id: str, error: Exception):
+        super().__init__(
+            f"Failed to build context for thought {thought_id}: {error}",
+            {"thought_id": thought_id, "original_error": str(error)},
+        )
+        self.thought_id = thought_id
+        self.original_error = error

ciris_engine/logic/processors/states/__init__.py

@@ -0,0 +1 @@
+"""State processors module."""