ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/runtime/component_builder.py

@@ -0,0 +1,361 @@
+"""
+Component builder for CIRIS Agent runtime.
+
+Handles the construction of all processing components.
+"""
+
+import logging
+from typing import Any, Optional
+
+from ciris_engine.logic.conscience import (
+    CoherenceConscience,
+    EntropyConscience,
+    EpistemicHumilityConscience,
+    OptimizationVetoConscience,
+    conscienceRegistry,
+)
+from ciris_engine.logic.conscience.thought_depth_guardrail import ThoughtDepthGuardrail
+from ciris_engine.logic.conscience.updated_status_conscience import UpdatedStatusConscience
+from ciris_engine.logic.context.builder import ContextBuilder
+from ciris_engine.logic.dma.action_selection_pdma import ActionSelectionPDMAEvaluator
+from ciris_engine.logic.dma.csdma import CSDMAEvaluator
+from ciris_engine.logic.dma.factory import create_dsdma_from_identity
+from ciris_engine.logic.dma.pdma import EthicalPDMAEvaluator
+from ciris_engine.logic.infrastructure.handlers.base_handler import ActionHandlerDependencies
+from ciris_engine.logic.infrastructure.handlers.handler_registry import build_action_dispatcher
+from ciris_engine.logic.processors import AgentProcessor
+from ciris_engine.logic.processors.core.thought_processor import ThoughtProcessor
+from ciris_engine.logic.processors.support.dma_orchestrator import DMAOrchestrator
+from ciris_engine.logic.utils.graphql_context_provider import GraphQLContextProvider
+from ciris_engine.logic.utils.shutdown_manager import register_global_shutdown_handler
+from ciris_engine.schemas.processors.base import ProcessorServices
+
+logger = logging.getLogger(__name__)
+
+
+class ComponentBuilder:
+    """Builds all processing components for the runtime."""
+
+    def __init__(self, runtime: Any) -> None:
+        """
+        Initialize component builder.
+
+        Args:
+            runtime: Reference to the main runtime for access to services and config
+        """
+        self.runtime = runtime
+        self.agent_processor: Optional[AgentProcessor] = None
+
+    async def build_all_components(self) -> AgentProcessor:
+        """Build all processing components and return the agent processor."""
+        if not self.runtime.llm_service:
+            raise RuntimeError("LLM service not initialized")
+
+        if not self.runtime.service_registry:
+            raise RuntimeError("Service registry not initialized")
+
+        config = self.runtime._ensure_config()
+
+        # For values not in EssentialConfig, use defaults
+        # (These would come from GraphConfigService once fully migrated)
+
+        # Build DMAs
+        ethical_pdma = EthicalPDMAEvaluator(
+            service_registry=self.runtime.service_registry,
+            model_name=self.runtime.llm_service.model_name,
+            max_retries=config.services.llm_max_retries,
+            sink=self.runtime.bus_manager,
+        )
+
+        # Get overrides from agent identity
+        csdma_overrides = None
+        if self.runtime.agent_identity and hasattr(self.runtime.agent_identity, "core_profile"):
+            csdma_overrides = self.runtime.agent_identity.core_profile.csdma_overrides
+
+        csdma = CSDMAEvaluator(
+            service_registry=self.runtime.service_registry,
+            model_name=self.runtime.llm_service.model_name,
+            max_retries=config.services.llm_max_retries,
+            prompt_overrides=csdma_overrides,
+            sink=self.runtime.bus_manager,
+        )
+
+        # Get action selection overrides from agent identity
+        action_selection_overrides = None
+        if self.runtime.agent_identity and hasattr(self.runtime.agent_identity, "core_profile"):
+            action_selection_overrides = self.runtime.agent_identity.core_profile.action_selection_pdma_overrides
+
+        action_pdma = ActionSelectionPDMAEvaluator(
+            service_registry=self.runtime.service_registry,
+            model_name=self.runtime.llm_service.model_name,
+            max_retries=config.services.llm_max_retries,
+            prompt_overrides=action_selection_overrides,
+            sink=self.runtime.bus_manager,
+        )
+
+        # Create DSDMA using agent's identity
+        if not self.runtime.agent_identity:
+            raise RuntimeError("Cannot create DSDMA - no agent identity loaded from graph!")
+
+        # Create identity configuration for DSDMA
+        from ciris_engine.schemas.config.agent import AgentTemplate, DSDMAConfiguration
+
+        # Create DSDMAConfiguration object
+        dsdma_config = None
+        domain_knowledge = getattr(self.runtime.agent_identity.core_profile, "domain_specific_knowledge", {})
+        prompt_template = getattr(self.runtime.agent_identity.core_profile, "dsdma_prompt_template", None)
+
+        if domain_knowledge or prompt_template:
+            dsdma_config = DSDMAConfiguration(
+                domain_specific_knowledge=domain_knowledge, prompt_template=prompt_template
+            )
+
+        identity_config = AgentTemplate(
+            name=self.runtime.agent_identity.agent_id,
+            description=self.runtime.agent_identity.core_profile.description,
+            role_description=self.runtime.agent_identity.core_profile.role_description,
+            dsdma_kwargs=dsdma_config,
+            csdma_overrides=self.runtime.agent_identity.core_profile.csdma_overrides,
+            action_selection_pdma_overrides=self.runtime.agent_identity.core_profile.action_selection_pdma_overrides,
+        )
+
+        dsdma = create_dsdma_from_identity(
+            identity_config,
+            self.runtime.service_registry,
+            model_name=self.runtime.llm_service.model_name,
+            sink=self.runtime.bus_manager,
+        )
+
+        # Get time service directly from service_initializer (not from registry)
+        time_service = getattr(self.runtime.service_initializer, "time_service", None)
+        if not time_service:
+            raise RuntimeError("TimeService not available from service_initializer - required for consciences")
+
+        # Build consciences
+        conscience_registry = conscienceRegistry()
+        # Create conscience config
+        from ciris_engine.logic.conscience.core import ConscienceConfig
+
+        conscience_config = ConscienceConfig()
+
+        # Register UpdatedStatusConscience FIRST (priority -1) to detect channel updates
+        # CRITICAL: bypass_exemption=True ensures it runs even for TASK_COMPLETE
+        conscience_registry.register_conscience(
+            "updated_status",
+            UpdatedStatusConscience(time_service=time_service),
+            priority=-1,  # Run BEFORE all other consciences
+            bypass_exemption=True,  # Must run even for exempt actions like TASK_COMPLETE
+        )
+
+        conscience_registry.register_conscience(
+            "entropy",
+            EntropyConscience(
+                self.runtime.service_registry,
+                conscience_config,
+                self.runtime.llm_service.model_name,
+                self.runtime.bus_manager,
+                time_service,
+            ),
+            priority=0,
+        )
+        conscience_registry.register_conscience(
+            "coherence",
+            CoherenceConscience(
+                self.runtime.service_registry,
+                conscience_config,
+                self.runtime.llm_service.model_name,
+                self.runtime.bus_manager,
+                time_service,
+            ),
+            priority=1,
+        )
+        conscience_registry.register_conscience(
+            "optimization_veto",
+            OptimizationVetoConscience(
+                self.runtime.service_registry,
+                conscience_config,
+                self.runtime.llm_service.model_name,
+                self.runtime.bus_manager,
+                time_service,
+            ),
+            priority=2,
+        )
+        conscience_registry.register_conscience(
+            "epistemic_humility",
+            EpistemicHumilityConscience(
+                self.runtime.service_registry,
+                conscience_config,
+                self.runtime.llm_service.model_name,
+                self.runtime.bus_manager,
+                time_service,
+            ),
+            priority=3,
+        )
+
+        conscience_registry.register_conscience(
+            "thought_depth",
+            ThoughtDepthGuardrail(time_service=time_service, max_depth=config.security.max_thought_depth),
+            priority=4,
+        )
+
+        # Build context provider
+        graphql_provider = GraphQLContextProvider(
+            graphql_client=None,  # Remote GraphQL disabled in essential config
+            memory_service=self.runtime.memory_service,
+            enable_remote_graphql=False,  # Remote GraphQL disabled in essential config
+        )
+
+        # Build orchestrators
+        dma_orchestrator = DMAOrchestrator(
+            ethical_pdma,
+            csdma,
+            dsdma,
+            action_pdma,
+            time_service=self.runtime.time_service,
+            app_config=self.runtime.essential_config,
+            llm_service=self.runtime.llm_service,
+            memory_service=self.runtime.memory_service,
+        )
+
+        context_builder = ContextBuilder(
+            memory_service=self.runtime.memory_service,
+            graphql_provider=graphql_provider,
+            app_config=self.runtime.essential_config,
+            telemetry_service=self.runtime.telemetry_service,
+            runtime=self.runtime,
+            service_registry=self.runtime.service_registry,
+            secrets_service=self.runtime.secrets_service,
+            resource_monitor=self.runtime.resource_monitor,
+            time_service=self.runtime.time_service,
+        )
+
+        # Register core services before building action dispatcher
+        self.runtime._register_core_services()
+
+        # Build action handler dependencies
+        # Use the BusManager from runtime instead of creating a new one
+        bus_manager = self.runtime.bus_manager
+
+        dependencies = ActionHandlerDependencies(
+            bus_manager=bus_manager,
+            time_service=self.runtime.time_service,
+            shutdown_callback=lambda: self.runtime.request_shutdown(
+                "Handler requested shutdown due to critical service failure"
+            ),
+            secrets_service=getattr(self.runtime, "secrets_service", None),
+        )
+
+        # Register global shutdown handler
+        register_global_shutdown_handler(lambda: self.runtime.request_shutdown("Global shutdown manager triggered"))
+
+        # Build thought processor
+        if not self.runtime.essential_config:
+            raise RuntimeError("AppConfig is required for ThoughtProcessor initialization")
+
+        thought_processor = ThoughtProcessor(
+            dma_orchestrator,
+            context_builder,
+            conscience_registry,  # Pass registry directly
+            self.runtime.essential_config,
+            dependencies,
+            telemetry_service=self.runtime.telemetry_service,
+            time_service=self.runtime.time_service,
+        )
+
+        # Build action dispatcher
+        action_dispatcher = self._build_action_dispatcher(dependencies)
+
+        # Build agent processor
+        if not self.runtime.essential_config:
+            raise RuntimeError("AppConfig is required for AgentProcessor initialization")
+        if not self.runtime.agent_identity:
+            raise RuntimeError("Agent identity is required for AgentProcessor initialization")
+
+        # Create ProcessorServices with all required services
+        processor_services = ProcessorServices(
+            llm_service=self.runtime.llm_service,
+            memory_service=self.runtime.memory_service,
+            audit_service=self.runtime.audit_service,
+            service_registry=self.runtime.service_registry,
+            time_service=self.runtime.time_service,
+            resource_monitor=self.runtime.resource_monitor,
+            secrets_service=self.runtime.secrets_service,
+            telemetry_service=self.runtime.telemetry_service,
+            app_config=self.runtime.essential_config,
+            graphql_provider=graphql_provider,  # Use the actual GraphQL provider
+            runtime=self.runtime,
+            communication_bus=self.runtime.bus_manager.communication,
+        )
+
+        # Get cognitive behaviors from graph (populated by migration on first-run or pre-1.7 upgrade)
+        cognitive_behaviors = await self._get_cognitive_behaviors_from_graph()
+
+        self.agent_processor = AgentProcessor(
+            app_config=self.runtime.essential_config,
+            agent_identity=self.runtime.agent_identity,
+            thought_processor=thought_processor,
+            action_dispatcher=action_dispatcher,
+            services=processor_services,
+            startup_channel_id=self.runtime.startup_channel_id,
+            time_service=self.runtime.time_service,  # Add missing parameter
+            runtime=self.runtime,  # Pass runtime reference for preload tasks
+            agent_occurrence_id=self.runtime.essential_config.agent_occurrence_id,  # Pass occurrence_id from config
+            cognitive_behaviors=cognitive_behaviors,  # Template-driven state transition config
+        )
+
+        return self.agent_processor
+
+    def _build_action_dispatcher(self, dependencies: Any) -> Any:
+        """Build action dispatcher. Override in subclasses for custom sinks."""
+        _config = self.runtime._ensure_config()
+        return build_action_dispatcher(
+            bus_manager=dependencies.bus_manager,
+            time_service=dependencies.time_service,
+            shutdown_callback=dependencies.shutdown_callback,
+            max_rounds=10,  # Default max rounds, can be configured via limits
+            telemetry_service=self.runtime.telemetry_service,
+            secrets_service=dependencies.secrets_service,
+            audit_service=self.runtime.audit_service,
+        )
+
+    async def _get_cognitive_behaviors_from_graph(self) -> Optional[Any]:
+        """Get cognitive state behaviors from graph database.
+
+        The migration in ciris_runtime populates this on:
+        1. First-run: Seeds from template
+        2. Pre-1.7 upgrade: Creates legacy-compatible config (PLAY/DREAM/SOLITUDE disabled)
+
+        Returns:
+            CognitiveStateBehaviors if found in graph, None otherwise
+        """
+        from ciris_engine.schemas.config.cognitive_state_behaviors import CognitiveStateBehaviors
+
+        logger.info("[COGNITIVE_LOAD] Loading cognitive behaviors from graph...")
+
+        if not self.runtime.service_initializer or not self.runtime.service_initializer.config_service:
+            logger.warning("[COGNITIVE_LOAD] Cannot get cognitive behaviors - GraphConfigService not available")
+            return None
+
+        config_service = self.runtime.service_initializer.config_service
+
+        try:
+            config_entry = await config_service.get_config("cognitive_state_behaviors")
+            if config_entry and config_entry.value and config_entry.value.dict_value:
+                dict_value = config_entry.value.dict_value
+                wakeup_config = dict_value.get("wakeup", {})
+                logger.info(
+                    f"[COGNITIVE_LOAD] Found in graph: wakeup.enabled={wakeup_config.get('enabled', 'MISSING')}"
+                )
+                behaviors = CognitiveStateBehaviors(**dict_value)
+                logger.info(f"[COGNITIVE_LOAD] Parsed: wakeup.enabled={behaviors.wakeup.enabled}")
+                return behaviors
+            else:
+                logger.info("[COGNITIVE_LOAD] Config entry exists but has no dict_value")
+        except Exception as e:
+            logger.warning(f"[COGNITIVE_LOAD] Failed to get cognitive behaviors from graph: {e}")
+
+        # Fallback: return default (full Covenant compliance)
+        logger.info(
+            "[COGNITIVE_LOAD] No cognitive behaviors in graph - using Covenant-compliant defaults (wakeup.enabled=True)"
+        )
+        return CognitiveStateBehaviors()

ciris_engine/logic/runtime/identity_manager.py

@@ -0,0 +1,219 @@
+"""
+Identity management for CIRIS Agent runtime.
+
+Handles loading, creating, and persisting agent identity.
+"""
+
+import hashlib
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ciris_engine.constants import CIRIS_VERSION
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.config.agent import AgentTemplate
+from ciris_engine.schemas.config.essential import EssentialConfig
+from ciris_engine.schemas.runtime.core import AgentIdentityRoot, CoreProfile, IdentityMetadata
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+class IdentityManager:
+    """Manages agent identity lifecycle."""
+
+    def __init__(self, config: EssentialConfig, time_service: TimeServiceProtocol) -> None:
+        self.config = config
+        self.time_service = time_service
+        self.agent_identity: Optional[AgentIdentityRoot] = None
+        # NOTE: agent_template is ONLY set during first-run seeding, then never used again
+        # All operational config (including tickets) should come from the graph after seeding
+        self.agent_template: Optional[AgentTemplate] = None
+
+    async def initialize_identity(self) -> AgentIdentityRoot:
+        """Initialize agent identity - create from template on first run, load from graph thereafter."""
+        # Check if identity exists in graph
+        identity_data = await self._get_identity_from_graph()
+
+        if identity_data:
+            # Identity exists - load it from graph
+            # IMPORTANT: Template is COMPLETELY IGNORED when identity already exists
+            # All config (identity, operational, tickets, etc.) comes from the graph
+            logger.info("Loading existing agent identity from graph (template ignored entirely)")
+            self.agent_identity = AgentIdentityRoot.model_validate(identity_data)
+            # self.agent_template remains None - template is not used after first run
+        else:
+            # First run - use template to create initial identity
+            logger.info("No identity found, creating from template (first run only)")
+
+            # Load template ONLY for initial identity creation
+            # Use default_template from config as the template name
+            from ciris_engine.logic.utils.path_resolution import find_template_file
+
+            template_name = getattr(self.config, "default_template", "default")
+            template_path = find_template_file(template_name)
+            if template_path:
+                initial_template = await self._load_template(template_path)
+            else:
+                initial_template = None
+
+            if not initial_template:
+                logger.warning(f"Template '{template_name}' not found, using default")
+                default_path = find_template_file("default")
+                if default_path:
+                    initial_template = await self._load_template(default_path)
+
+            if not initial_template:
+                raise RuntimeError("No template available for initial identity creation")
+
+            # Store template temporarily - only used during this seeding process
+            # After seeding, all config comes from graph
+            # NOTE: Tickets config will be migrated to graph by ciris_runtime._migrate_tickets_config_to_graph()
+            self.agent_template = initial_template
+
+            # Create identity from template and save to graph
+            self.agent_identity = self._create_identity_from_template(initial_template)
+            await self._save_identity_to_graph(self.agent_identity)
+
+        return self.agent_identity
+
+    async def _load_template(self, template_path: Path) -> Optional[AgentTemplate]:
+        """Load template from file."""
+        from ciris_engine.logic.utils.profile_loader import load_template
+
+        return await load_template(template_path)
+
+    async def _get_identity_from_graph(
+        self,
+    ) -> Optional[JSONDict]:  # NOSONAR: Maintains async consistency in identity chain
+        """Retrieve agent identity from the persistence tier."""
+        try:
+            from ciris_engine.logic.config import get_sqlite_db_full_path
+            from ciris_engine.logic.persistence.models.identity import retrieve_agent_identity
+
+            # Get the correct db path from our config
+            db_path = get_sqlite_db_full_path(self.config)
+            identity = retrieve_agent_identity(db_path=db_path)
+            if identity:
+                return identity.model_dump()
+
+        except Exception as e:
+            logger.warning(f"Failed to retrieve identity from persistence: {e}")
+
+        return None
+
+    async def _save_identity_to_graph(self, identity: AgentIdentityRoot) -> None:
+        """Save agent identity to the persistence tier."""
+        try:
+            from ciris_engine.logic.config import get_sqlite_db_full_path
+            from ciris_engine.logic.persistence.models.identity import store_agent_identity
+
+            # Get the correct db path from our config
+            db_path = get_sqlite_db_full_path(self.config)
+            success = store_agent_identity(identity, self.time_service, db_path=db_path)
+            if success:
+                logger.info("Agent identity saved to persistence tier")
+            else:
+                raise RuntimeError("Failed to store agent identity")
+
+        except Exception as e:
+            logger.error(f"Failed to save identity to persistence: {e}")
+            raise
+
+    def _create_identity_from_template(self, template: AgentTemplate) -> AgentIdentityRoot:
+        """Create initial identity from template (first run only)."""
+        # Generate deterministic identity hash
+        identity_string = f"{template.name}:{template.description}:{template.role_description}"
+        identity_hash = hashlib.sha256(identity_string.encode()).hexdigest()
+
+        # Extract DSDMA configuration from template
+        domain_knowledge = {}
+        dsdma_prompt_template = None
+
+        if template.dsdma_kwargs:
+            # Extract domain knowledge from typed model
+            if template.dsdma_kwargs.domain_specific_knowledge:
+                for key, value in template.dsdma_kwargs.domain_specific_knowledge.items():
+                    if isinstance(value, dict):
+                        # Convert nested dicts to JSON strings
+                        import json
+
+                        domain_knowledge[key] = json.dumps(value)
+                    else:
+                        domain_knowledge[key] = str(value)
+
+            # Extract prompt template
+            if template.dsdma_kwargs.prompt_template:
+                dsdma_prompt_template = template.dsdma_kwargs.prompt_template
+
+        # Create identity root from template
+        return AgentIdentityRoot(
+            agent_id=template.name,
+            identity_hash=identity_hash,
+            core_profile=CoreProfile(
+                description=template.description,
+                role_description=template.role_description,
+                domain_specific_knowledge=domain_knowledge,
+                dsdma_prompt_template=dsdma_prompt_template,
+                csdma_overrides={
+                    k: v
+                    for k, v in (template.csdma_overrides.__dict__ if template.csdma_overrides else {}).items()
+                    if v is not None
+                },
+                action_selection_pdma_overrides={
+                    k: v
+                    for k, v in (
+                        template.action_selection_pdma_overrides.__dict__
+                        if template.action_selection_pdma_overrides
+                        else {}
+                    ).items()
+                    if v is not None
+                },
+                last_shutdown_memory=None,
+            ),
+            identity_metadata=IdentityMetadata(
+                created_at=self.time_service.now(),
+                last_modified=self.time_service.now(),
+                modification_count=0,
+                creator_agent_id="system",
+                lineage_trace=["system"],
+                approval_required=True,
+                approved_by=None,
+                approval_timestamp=None,
+                version=CIRIS_VERSION,  # Use actual CIRIS version
+            ),
+            permitted_actions=[
+                HandlerActionType.OBSERVE,
+                HandlerActionType.SPEAK,
+                HandlerActionType.TOOL,
+                HandlerActionType.MEMORIZE,
+                HandlerActionType.RECALL,
+                HandlerActionType.FORGET,
+                HandlerActionType.DEFER,
+                HandlerActionType.REJECT,
+                HandlerActionType.PONDER,
+                HandlerActionType.TASK_COMPLETE,
+            ],
+            restricted_capabilities=[
+                "identity_change_without_approval",
+                "profile_switching",
+                "unauthorized_data_access",
+            ],
+        )
+
+    async def verify_identity_integrity(self) -> bool:
+        """Verify identity has been properly loaded."""
+        if not self.agent_identity:
+            logger.error("No agent identity loaded")
+            return False
+
+        # Verify core fields
+        required_fields = ["agent_id", "identity_hash", "core_profile"]
+        for field in required_fields:
+            if not hasattr(self.agent_identity, field) or not getattr(self.agent_identity, field):
+                logger.error(f"Identity missing required field: {field}")
+                return False
+
+        logger.info("✓ Agent identity verified")
+        return True