ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/processors/support/__init__.py

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

ciris_engine/logic/processors/support/dma_orchestrator.py

@@ -0,0 +1,336 @@
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ciris_engine.logic.dma.action_selection_pdma import ActionSelectionPDMAEvaluator
+from ciris_engine.logic.dma.csdma import CSDMAEvaluator
+from ciris_engine.logic.dma.dma_executor import (
+    run_action_selection_pdma,
+    run_csdma,
+    run_dma_with_retries,
+    run_dsdma,
+    run_pdma,
+)
+from ciris_engine.logic.dma.dsdma_base import BaseDSDMA
+from ciris_engine.logic.dma.pdma import EthicalPDMAEvaluator
+from ciris_engine.logic.processors.support.processing_queue import ProcessingQueueItem
+from ciris_engine.logic.registries.circuit_breaker import CircuitBreaker
+from ciris_engine.logic.utils.channel_utils import extract_channel_id
+from ciris_engine.schemas.dma.faculty import EnhancedDMAInputs
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult, CSDMAResult, DSDMAResult, EthicalDMAResult
+from ciris_engine.schemas.processors.core import DMAResults
+from ciris_engine.schemas.processors.dma import DMAError, DMAErrors, DMAMetadata, InitialDMAResults
+from ciris_engine.schemas.runtime.models import Thought
+
+if TYPE_CHECKING:
+    from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class DMAOrchestrator:
+    def __init__(
+        self,
+        ethical_pdma_evaluator: EthicalPDMAEvaluator,
+        csdma_evaluator: CSDMAEvaluator,
+        dsdma: Optional[BaseDSDMA],
+        action_selection_pdma_evaluator: ActionSelectionPDMAEvaluator,
+        time_service: "TimeServiceProtocol",
+        app_config: Optional[Any] = None,
+        llm_service: Optional[Any] = None,
+        memory_service: Optional[Any] = None,
+    ) -> None:
+        self.ethical_pdma_evaluator = ethical_pdma_evaluator
+        self.csdma_evaluator = csdma_evaluator
+        self.dsdma = dsdma
+        self.action_selection_pdma_evaluator = action_selection_pdma_evaluator
+        self.time_service = time_service
+        self.app_config = app_config
+        self.llm_service = llm_service
+        self.memory_service = memory_service
+
+        self.retry_limit = getattr(app_config.workflow, "DMA_RETRY_LIMIT", 3) if app_config else 3
+        self.timeout_seconds = getattr(app_config.workflow, "DMA_TIMEOUT_SECONDS", 30.0) if app_config else 30.0
+
+        self._circuit_breakers: Dict[str, CircuitBreaker] = {
+            "ethical_pdma": CircuitBreaker("ethical_pdma"),
+            "csdma": CircuitBreaker("csdma"),
+        }
+        if self.dsdma is not None:
+            self._circuit_breakers["dsdma"] = CircuitBreaker("dsdma")
+
+    async def run_initial_dmas(
+        self,
+        thought_item: ProcessingQueueItem,
+        processing_context: Optional[Any] = None,  # ProcessingThoughtContext, but using Any to avoid circular import
+        dsdma_context: Optional[DMAMetadata] = None,
+    ) -> InitialDMAResults:
+        """
+        Run EthicalPDMA, CSDMA, and DSDMA in parallel (async). All 3 DMA results are required.
+        """
+        logger.debug(f"[DEBUG TIMING] run_initial_dmas START for thought {thought_item.thought_id}")
+
+        # FAIL FAST: All 3 DMAs are required
+        if not self.dsdma:
+            raise RuntimeError("DSDMA is not configured - all 3 DMA results (ethical_pdma, csdma, dsdma) are required")
+
+        errors = DMAErrors()
+        tasks = {
+            "ethical_pdma": asyncio.create_task(
+                run_dma_with_retries(
+                    run_pdma,
+                    self.ethical_pdma_evaluator,
+                    thought_item,
+                    processing_context,
+                    retry_limit=self.retry_limit,
+                    timeout_seconds=self.timeout_seconds,
+                    time_service=self.time_service,
+                )
+            ),
+            "csdma": asyncio.create_task(
+                run_dma_with_retries(
+                    run_csdma,
+                    self.csdma_evaluator,
+                    thought_item,
+                    processing_context,
+                    retry_limit=self.retry_limit,
+                    timeout_seconds=self.timeout_seconds,
+                    time_service=self.time_service,
+                )
+            ),
+            "dsdma": asyncio.create_task(
+                run_dma_with_retries(
+                    run_dsdma,
+                    self.dsdma,
+                    thought_item,
+                    dsdma_context or DMAMetadata(),
+                    retry_limit=self.retry_limit,
+                    timeout_seconds=self.timeout_seconds,
+                    time_service=self.time_service,
+                )
+            ),
+        }
+
+        # Collect results - must get ALL 3
+        dma_results = {}
+        for name, task in tasks.items():
+            try:
+                dma_results[name] = await task
+            except Exception as e:
+                logger.error(f"DMA '{name}' failed: {e}", exc_info=True)
+                error = DMAError(dma_name=name, error_message=str(e), error_type=type(e).__name__)
+                if name == "ethical_pdma":
+                    errors.ethical_pdma = error
+                elif name == "csdma":
+                    errors.csdma = error
+                elif name == "dsdma":
+                    errors.dsdma = error
+
+        if errors.has_errors():
+            raise Exception(f"DMA(s) failed: {errors.get_error_summary()}")
+
+        # Capture prompts from evaluators (set during evaluation)
+        ethical_pdma_prompt = getattr(self.ethical_pdma_evaluator, "last_user_prompt", None)
+        csdma_prompt = getattr(self.csdma_evaluator, "last_user_prompt", None)
+        dsdma_prompt = getattr(self.dsdma, "last_user_prompt", None) if self.dsdma else None
+
+        # Create InitialDMAResults with all 3 required fields and prompts
+        return InitialDMAResults(
+            ethical_pdma=dma_results["ethical_pdma"],
+            csdma=dma_results["csdma"],
+            dsdma=dma_results["dsdma"],
+            ethical_pdma_prompt=ethical_pdma_prompt,
+            csdma_prompt=csdma_prompt,
+            dsdma_prompt=dsdma_prompt,
+        )
+
+    async def run_dmas(
+        self,
+        thought_item: ProcessingQueueItem,
+        processing_context: Optional[Any] = None,  # ProcessingThoughtContext, but using Any to avoid circular import
+        dsdma_context: Optional[DMAMetadata] = None,
+    ) -> "DMAResults":
+        """Run all DMAs with circuit breaker protection."""
+
+        from ciris_engine.schemas.processors.core import DMAResults
+
+        results = DMAResults()
+        tasks: Dict[str, asyncio.Task[Any]] = {}
+
+        # Ethical PDMA
+        cb = self._circuit_breakers.get("ethical_pdma")
+        if cb and cb.is_available():
+            tasks["ethical_pdma"] = asyncio.create_task(
+                run_dma_with_retries(
+                    run_pdma,
+                    self.ethical_pdma_evaluator,
+                    thought_item,
+                    processing_context,
+                    retry_limit=self.retry_limit,
+                    timeout_seconds=self.timeout_seconds,
+                    time_service=self.time_service,
+                )
+            )
+        else:
+            results.errors.append("ethical_pdma circuit open")
+
+        # CSDMA
+        cb = self._circuit_breakers.get("csdma")
+        if cb and cb.is_available():
+            tasks["csdma"] = asyncio.create_task(
+                run_dma_with_retries(
+                    run_csdma,
+                    self.csdma_evaluator,
+                    thought_item,
+                    processing_context,
+                    retry_limit=self.retry_limit,
+                    timeout_seconds=self.timeout_seconds,
+                    time_service=self.time_service,
+                )
+            )
+        else:
+            results.errors.append("csdma circuit open")
+
+        # DSDMA (required)
+        if self.dsdma:
+            cb = self._circuit_breakers.get("dsdma")
+            if cb and cb.is_available():
+                tasks["dsdma"] = asyncio.create_task(
+                    run_dma_with_retries(
+                        run_dsdma,
+                        self.dsdma,
+                        thought_item,
+                        dsdma_context or DMAMetadata(),
+                        retry_limit=self.retry_limit,
+                        timeout_seconds=self.timeout_seconds,
+                        time_service=self.time_service,
+                    )
+                )
+            elif cb:
+                results.errors.append("dsdma circuit open")
+        else:
+            # FAIL FAST: All 3 DMA results are required
+            raise RuntimeError("DSDMA is not configured - all 3 DMA results (ethical_pdma, csdma, dsdma) are required")
+
+        if tasks:
+            task_results = await asyncio.gather(*tasks.values(), return_exceptions=True)
+            for (name, _), outcome in zip(tasks.items(), task_results):
+                cb = self._circuit_breakers.get(name)
+                if isinstance(outcome, Exception):
+                    logger.error(f"DMA '{name}' failed: {outcome}", exc_info=True)
+                    results.errors.append(str(outcome))
+                    if cb:
+                        cb.record_failure()
+                else:
+                    if cb:
+                        cb.record_success()
+                    if name == "ethical_pdma":
+                        if isinstance(outcome, EthicalDMAResult):
+                            results.ethical_pdma = outcome
+                        else:
+                            logger.error(f"Unexpected outcome type for ethical_pdma: {type(outcome)}")
+                    elif name == "csdma":
+                        if isinstance(outcome, CSDMAResult):
+                            results.csdma = outcome
+                        else:
+                            logger.error(f"Unexpected outcome type for csdma: {type(outcome)}")
+                    elif name == "dsdma":
+                        if isinstance(outcome, DSDMAResult):
+                            results.dsdma = outcome
+                        else:
+                            logger.error(f"Unexpected outcome type for dsdma: {type(outcome)}")
+
+        return results
+
+    async def run_action_selection(
+        self,
+        thought_item: ProcessingQueueItem,
+        actual_thought: Thought,
+        processing_context: Any,  # ProcessingThoughtContext, but using Any to avoid circular import
+        dma_results: InitialDMAResults,
+        profile_name: str,
+    ) -> ActionSelectionDMAResult:
+        """Run ActionSelectionPDMAEvaluator sequentially after DMAs."""
+        # Create properly typed EnhancedDMAInputs
+        # Pass images from thought_item (ProcessingQueueItem) for multimodal support
+        triaged = EnhancedDMAInputs(
+            original_thought=actual_thought,
+            processing_context=processing_context,
+            ethical_pdma_result=dma_results.ethical_pdma,
+            csdma_result=dma_results.csdma,
+            dsdma_result=dma_results.dsdma,
+            current_thought_depth=getattr(actual_thought, "thought_depth", 0),
+            max_rounds=5,  # Default max rounds
+            faculty_enhanced=False,
+            recursive_evaluation=False,
+            images=thought_item.images,  # Pass images for ActionSelectionPDMA vision
+        )
+
+        # Check if this is a conscience retry from the context
+        if hasattr(processing_context, "is_conscience_retry") and processing_context.is_conscience_retry:
+            triaged.recursive_evaluation = True
+
+        channel_id = None
+
+        # Try to get channel_id from various sources
+        if processing_context.system_snapshot and processing_context.system_snapshot.channel_context:
+            channel_id = extract_channel_id(processing_context.system_snapshot.channel_context)
+
+        if not channel_id and processing_context.initial_task_context:
+            channel_context = getattr(processing_context.initial_task_context, "channel_context", None)
+            if channel_context:
+                channel_id = extract_channel_id(channel_context)
+
+        # Update fields on the Pydantic model directly
+        if triaged.current_thought_depth == 0:  # Only set if not already set
+            triaged.current_thought_depth = actual_thought.thought_depth
+
+        if self.app_config and hasattr(self.app_config, "workflow"):
+            if triaged.max_rounds == 5:  # Only update if still default
+                triaged.max_rounds = self.app_config.workflow.max_rounds
+        else:
+            logger.warning("DMAOrchestrator: app_config or workflow config not found for max_rounds, using default.")
+
+        # Get identity from persistence tier
+        from ciris_engine.logic.persistence.models import get_identity_for_context
+        from ciris_engine.schemas.infrastructure.identity_variance import IdentityData
+
+        identity_info = get_identity_for_context()
+        # Convert IdentityContext to IdentityData for EnhancedDMAInputs
+        triaged.agent_identity = IdentityData(
+            agent_id=identity_info.agent_name,  # IdentityContext.agent_name
+            description=identity_info.description,
+            role=identity_info.agent_role,  # IdentityContext.agent_role
+            trust_level=0.5,  # Default trust level (IdentityContext doesn't have this field)
+        )
+
+        logger.debug(f"Using identity '{identity_info.agent_name}' for thought {thought_item.thought_id}")
+
+        # Get permitted actions directly from identity
+        permitted_actions = identity_info.permitted_actions
+
+        # Identity MUST have permitted actions - no defaults in a mission critical system
+        triaged.permitted_actions = permitted_actions
+
+        # Pass through conscience feedback if available
+        if hasattr(thought_item, "conscience_feedback") and thought_item.conscience_feedback:
+            triaged.conscience_feedback = thought_item.conscience_feedback
+
+        try:
+            result = await run_dma_with_retries(
+                run_action_selection_pdma,
+                self.action_selection_pdma_evaluator,
+                triaged,
+                retry_limit=self.retry_limit,
+                timeout_seconds=self.timeout_seconds,
+                time_service=self.time_service,
+            )
+        except Exception as e:
+            logger.error(f"ActionSelectionPDMA failed: {e}", exc_info=True)
+            raise
+
+        if isinstance(result, ActionSelectionDMAResult):
+            return result
+        else:
+            logger.error(f"Action selection returned unexpected type: {type(result)}")
+            raise TypeError(f"Expected ActionSelectionDMAResult, got {type(result)}")

ciris_engine/logic/processors/support/processing_queue.py

@@ -0,0 +1,133 @@
+import collections
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.runtime.enums import ThoughtType
+from ciris_engine.schemas.runtime.models import ImageContent, Thought, ThoughtContext
+
+# Import both types of ThoughtContext
+from ciris_engine.schemas.runtime.processing_context import ProcessingThoughtContext
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+class ThoughtContent(BaseModel):
+    """Typed content for a thought."""
+
+    text: str
+    metadata: JSONDict = Field(default_factory=dict)
+
+
+class ProcessingQueueItem(BaseModel):
+    """
+    Represents an item loaded into an in-memory processing queue (e.g., collections.deque).
+    This is a lightweight representation derived from a Thought, optimized for queue processing.
+    """
+
+    thought_id: str
+    source_task_id: str
+    thought_type: ThoughtType  # Corresponds to Thought.thought_type
+    content: ThoughtContent
+    agent_occurrence_id: str = Field(
+        default="default", description="Agent occurrence ID that owns this thought (multi-occurrence support)"
+    )
+    thought_depth: int = Field(
+        ..., ge=0, le=7, description="Current thought depth in the processing chain (REQUIRED, never defaults)"
+    )
+    raw_input_string: Optional[str] = Field(
+        default=None, description="The original input string that generated this thought, if applicable."
+    )
+    initial_context: Optional[Union[JSONDict, ProcessingThoughtContext, ThoughtContext]] = Field(
+        default=None, description="Initial context when the thought was first received/generated for processing."
+    )
+    ponder_notes: Optional[List[str]] = Field(
+        default=None, description="Key questions from a previous Ponder action if this item is being re-queued."
+    )
+    conscience_feedback: Optional[Any] = Field(
+        default=None, description="conscience evaluation feedback if applicable."
+    )
+    images: List[ImageContent] = Field(
+        default_factory=list, description="Images attached to this thought for multimodal processing"
+    )
+
+    @property
+    def content_text(self) -> str:
+        """Return a best-effort text representation of the content."""
+        return self.content.text
+
+    @classmethod
+    def from_thought(
+        cls,
+        thought_instance: Thought,
+        raw_input: Optional[str] = None,
+        initial_ctx: Optional[JSONDict] = None,
+        queue_item_content: Optional[Union[ThoughtContent, str, JSONDict]] = None,
+        task_images: Optional[List[ImageContent]] = None,
+    ) -> "ProcessingQueueItem":
+        """
+        Creates a ProcessingQueueItem from a Thought instance.
+
+        Args:
+            thought_instance: The thought to create a queue item from
+            raw_input: Optional raw input string
+            initial_ctx: Optional initial context
+            queue_item_content: Optional content override
+            task_images: Optional list of images from the source task. If not provided,
+                        the method will attempt to look up the task and get its images.
+        """
+        raw_initial_ctx = initial_ctx if initial_ctx is not None else thought_instance.context
+        # Accept ProcessingThoughtContext, ThoughtContext, dict, or any Pydantic model
+        if hasattr(raw_initial_ctx, "model_dump") or isinstance(
+            raw_initial_ctx, (dict, ProcessingThoughtContext, ThoughtContext)
+        ):
+            final_initial_ctx = raw_initial_ctx
+        else:
+            final_initial_ctx = None
+
+        raw_content = queue_item_content if queue_item_content is not None else thought_instance.content
+        if isinstance(raw_content, ThoughtContent):
+            resolved_content = raw_content
+        elif isinstance(raw_content, str):
+            resolved_content = ThoughtContent(text=raw_content)
+        else:  # isinstance(raw_content, dict)
+            resolved_content = ThoughtContent(**raw_content)
+
+        # Get images from task if not provided
+        # Images are stored at the TASK level, so all thoughts for a task share the same images
+        images: List[ImageContent] = []
+        if task_images is not None:
+            images = task_images
+        else:
+            # Look up the task to get its images
+            try:
+                from ciris_engine.logic.persistence.models.tasks import get_task_by_id
+
+                task = get_task_by_id(thought_instance.source_task_id, thought_instance.agent_occurrence_id)
+                if task and task.images:
+                    images = task.images
+                    if images:
+                        logger.info(
+                            f"[VISION] ProcessingQueueItem inheriting {len(images)} images "
+                            f"from task {thought_instance.source_task_id}"
+                        )
+            except Exception as e:
+                logger.warning(f"Failed to load task images for thought {thought_instance.thought_id}: {e}")
+
+        return cls(
+            thought_id=thought_instance.thought_id,
+            source_task_id=thought_instance.source_task_id,
+            thought_type=thought_instance.thought_type,
+            content=resolved_content,
+            agent_occurrence_id=thought_instance.agent_occurrence_id,
+            thought_depth=thought_instance.thought_depth,
+            raw_input_string=raw_input if raw_input is not None else str(thought_instance.content),
+            initial_context=final_initial_ctx,
+            ponder_notes=thought_instance.ponder_notes,
+            images=images,
+        )
+
+
+ProcessingQueue = collections.deque[ProcessingQueueItem]