ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/context/builder.py

@@ -0,0 +1,149 @@
+import logging
+from typing import Any, Dict, Optional
+
+from ciris_engine.logic.config.env_utils import get_env_var
+from ciris_engine.logic.secrets.service import SecretsService
+from ciris_engine.logic.services.memory_service import LocalGraphMemoryService
+from ciris_engine.logic.utils import GraphQLContextProvider
+from ciris_engine.schemas.runtime.models import Task, TaskContext, Thought
+from ciris_engine.schemas.runtime.processing_context import ProcessingThoughtContext
+from ciris_engine.schemas.runtime.system_context import SystemSnapshot
+from ciris_engine.schemas.types import JSONDict
+
+from .batch_context import build_system_snapshot_with_batch as _build_snapshot_unified
+from .channel_resolution import resolve_channel_id_and_context
+from .secrets_snapshot import build_secrets_snapshot as _secrets_snapshot
+
+logger = logging.getLogger(__name__)
+
+
+class ContextBuilder:
+    def __init__(
+        self,
+        memory_service: Optional[LocalGraphMemoryService] = None,
+        graphql_provider: Optional[GraphQLContextProvider] = None,
+        app_config: Optional[Any] = None,
+        telemetry_service: Optional[Any] = None,
+        secrets_service: Optional[SecretsService] = None,
+        runtime: Optional[Any] = None,
+        service_registry: Optional[Any] = None,
+        resource_monitor: Optional[Any] = None,  # Will be REQUIRED
+        time_service: Any = None,  # REQUIRED - will fail fast and loud if None
+    ) -> None:
+        self.memory_service = memory_service
+        self.graphql_provider = graphql_provider
+        self.app_config = app_config
+        self.telemetry_service = telemetry_service
+        self.secrets_service = secrets_service  # Must be provided, no fallback creation
+        self.runtime = runtime
+        self.service_registry = service_registry
+        self.resource_monitor = resource_monitor
+        self.time_service = time_service
+
+    async def build_thought_context(
+        self, thought: Thought, task: Optional[Task] = None, system_snapshot: Optional[SystemSnapshot] = None
+    ) -> ProcessingThoughtContext:
+        """Build complete context for thought processing."""
+        # Use provided snapshot or build new one
+        if system_snapshot:
+            system_snapshot_data = system_snapshot
+            logger.info("[CONTEXT] Using provided system snapshot")
+        else:
+            system_snapshot_data = await self.build_system_snapshot(task, thought)
+            logger.info("[CONTEXT] Built new system snapshot")
+        # Convert list of UserProfile to dict keyed by user_id
+        user_profiles_list = getattr(system_snapshot_data, "user_profiles", []) or []
+        user_profiles_data = {profile.user_id: profile for profile in user_profiles_list}
+        task_history_data = getattr(system_snapshot_data, "recently_completed_tasks_summary", None) or []
+
+        # Log user context details
+        if user_profiles_data:
+            logger.info(f"[CONTEXT] Built user profiles for {len(user_profiles_data)} users")
+            for user_id, profile in list(user_profiles_data.items())[:3]:  # Log first 3
+                logger.debug(f"[CONTEXT]   User {user_id}: {getattr(profile, 'name', 'unknown')}")
+
+        # Get identity context from memory service
+        identity_context_str = await self.memory_service.export_identity_context() if self.memory_service else None
+
+        # --- Mission-Critical Channel ID Resolution ---
+        # Use centralized channel resolution to avoid duplication
+        channel_id, _channel_context = await resolve_channel_id_and_context(
+            task=task, thought=thought, memory_service=self.memory_service, app_config=self.app_config
+        )
+
+        # Override with system snapshot's channel_id if present
+        if hasattr(system_snapshot_data, "channel_id") and system_snapshot_data.channel_id:
+            if channel_id != system_snapshot_data.channel_id:
+                logger.debug(
+                    f"[CONTEXT] Overriding resolved channel_id '{channel_id}' with "
+                    f"system_snapshot channel_id '{system_snapshot_data.channel_id}'"
+                )
+                channel_id = system_snapshot_data.channel_id
+
+        # Log final channel resolution
+        logger.info(f"[CONTEXT] Channel ID resolved: '{channel_id}'")
+
+        # Only set channel_id if it's not already set in system_snapshot
+        if channel_id and hasattr(system_snapshot_data, "channel_id"):
+            if not system_snapshot_data.channel_id:
+                system_snapshot_data.channel_id = channel_id
+            elif system_snapshot_data.channel_id != channel_id:
+                logger.warning(
+                    f"System snapshot already has channel_id '{system_snapshot_data.channel_id}', not overwriting with '{channel_id}'"
+                )
+
+        channel_context_str = f"Our assigned channel is {channel_id}" if channel_id else None
+        if identity_context_str and channel_context_str:
+            identity_context_str = f"{identity_context_str}\n{channel_context_str}"
+        elif channel_context_str:
+            identity_context_str = channel_context_str
+        initial_task_context = None
+        if task and hasattr(task, "context") and isinstance(task.context, TaskContext):
+            # task.context is typed as Optional[TaskContext], so we use it directly
+            initial_task_context = task.context
+        return ProcessingThoughtContext(
+            system_snapshot=system_snapshot_data,
+            user_profiles=user_profiles_data,
+            task_history=task_history_data,
+            identity_context=identity_context_str,
+            initial_task_context=initial_task_context,
+        )
+
+    async def build_system_snapshot(
+        self, task: Optional[Task], thought: Any  # Accept Thought or ProcessingQueueItem
+    ) -> SystemSnapshot:
+        """
+        Build system snapshot for the thought using unified batch approach.
+
+        This method now uses the unified batch snapshot builder which:
+        - Creates minimal batch context on-demand for single thoughts
+        - Uses pre-fetched batch context when available (batch processing)
+        - Ensures consistent snapshot building across all code paths
+        """
+        return await _build_snapshot_unified(
+            task=task,
+            thought=thought,
+            batch_data=None,  # Will create minimal batch context on-demand
+            memory_service=self.memory_service,
+            graphql_provider=self.graphql_provider,
+            time_service=self.time_service,
+            # Services for on-demand batch context creation
+            secrets_service=self.secrets_service,
+            service_registry=self.service_registry,
+            resource_monitor=self.resource_monitor,
+            telemetry_service=self.telemetry_service,
+            runtime=self.runtime,
+        )
+
+    async def _build_secrets_snapshot(self) -> JSONDict:
+        """Build secrets information for SystemSnapshot.
+
+        Returns JSON-compatible dict with SystemSnapshot secret fields:
+        - detected_secrets: List[str]
+        - secrets_filter_version: int
+        - total_secrets_stored: int
+        """
+        if self.secrets_service is None:
+            # Return empty snapshot if no secrets service
+            return {"detected_secrets": [], "secrets_filter_version": 0, "total_secrets_stored": 0}
+        return await _secrets_snapshot(self.secrets_service)

ciris_engine/logic/context/channel_resolution.py

@@ -0,0 +1,136 @@
+"""
+Centralized channel resolution logic.
+
+This module provides a single, authoritative implementation of channel ID
+resolution to prevent duplication and divergence between different parts
+of the codebase.
+"""
+
+import logging
+from typing import Any, Optional, Tuple
+
+from ciris_engine.logic.config.env_utils import get_env_var
+from ciris_engine.logic.services.memory_service import LocalGraphMemoryService
+from ciris_engine.schemas.runtime.models import Task
+from ciris_engine.schemas.runtime.system_context import ChannelContext
+
+from .system_snapshot_helpers import _resolve_channel_context
+
+logger = logging.getLogger(__name__)
+
+
+def _try_task_channel_id(task: Optional[Task]) -> Optional[str]:
+    """Try to get channel_id directly from task."""
+    if task and hasattr(task, "channel_id") and task.channel_id:
+        return str(task.channel_id)
+    return None
+
+
+def _try_app_config_home_channel(app_config: Optional[Any]) -> Optional[str]:
+    """Try to get channel_id from app_config home_channel."""
+    if app_config and hasattr(app_config, "home_channel"):
+        home_channel = getattr(app_config, "home_channel", None)
+        if home_channel:
+            return str(home_channel)
+    return None
+
+
+def _try_mode_specific_config(app_config: Optional[Any]) -> Optional[str]:
+    """Try mode-specific config attributes (discord_channel_id, cli_channel_id, api_channel_id)."""
+    if not app_config:
+        return None
+
+    config_attrs = ["discord_channel_id", "cli_channel_id", "api_channel_id"]
+    for attr in config_attrs:
+        if hasattr(app_config, attr):
+            config_channel_id = getattr(app_config, attr, None)
+            if config_channel_id:
+                logger.debug(f"Resolved channel_id '{config_channel_id}' from app_config.{attr}")
+                return str(config_channel_id)
+    return None
+
+
+def _try_mode_based_fallback(app_config: Optional[Any]) -> Optional[str]:
+    """Try mode-based fallbacks (CLI, API, DISCORD_DEFAULT)."""
+    if not app_config:
+        return None
+
+    mode = getattr(app_config, "agent_mode", "")
+    mode_lower = mode.lower() if mode else ""
+
+    if mode_lower == "cli":
+        logger.debug("Using CLI mode fallback channel_id")
+        return "CLI"
+    elif mode_lower == "api":
+        logger.debug("Using API mode fallback channel_id")
+        return "API"
+    elif mode == "discord":
+        logger.debug("Using Discord mode fallback channel_id")
+        return "DISCORD_DEFAULT"
+
+    return None
+
+
+async def resolve_channel_id_and_context(
+    task: Optional[Task],
+    thought: Any,
+    memory_service: Optional[LocalGraphMemoryService],
+    app_config: Optional[Any] = None,
+) -> Tuple[Optional[str], Optional[ChannelContext]]:
+    """
+    Resolve channel ID and context using a standardized resolution cascade.
+
+    Resolution order:
+    1. Task/thought context (from memory)
+    2. Task direct channel_id field
+    3. App config (home_channel, mode-specific channels)
+    4. Environment variable (DISCORD_CHANNEL_ID)
+    5. Mode-based fallbacks (CLI, API, DISCORD_DEFAULT)
+    6. Emergency fallback ("UNKNOWN")
+
+    Args:
+        task: Optional task containing channel context
+        thought: Thought object that may have channel context
+        memory_service: Memory service for graph lookups
+        app_config: Application configuration for fallback lookups
+
+    Returns:
+        Tuple of (channel_id, channel_context) where either may be None
+    """
+    # 1. Try memory-based resolution (most reliable)
+    channel_id, channel_context = await _resolve_channel_context(task, thought, memory_service)
+    if channel_id:
+        logger.debug(f"Resolved channel_id '{channel_id}' from memory")
+        return channel_id, channel_context
+
+    # 2. Try task's direct channel_id field
+    channel_id = _try_task_channel_id(task)
+    if channel_id:
+        logger.debug(f"Resolved channel_id '{channel_id}' from task.channel_id")
+        return channel_id, None
+
+    # 3. Try app config home channel
+    channel_id = _try_app_config_home_channel(app_config)
+    if channel_id:
+        logger.debug(f"Resolved channel_id '{channel_id}' from app_config.home_channel")
+        return channel_id, None
+
+    # 4. Try environment variable
+    channel_id = get_env_var("DISCORD_CHANNEL_ID")
+    if channel_id:
+        logger.debug(f"Resolved channel_id '{channel_id}' from DISCORD_CHANNEL_ID env var")
+        return channel_id, None
+
+    # 5. Try mode-specific config attributes
+    channel_id = _try_mode_specific_config(app_config)
+    if channel_id:
+        return channel_id, None
+
+    # 6. Mode-based fallbacks
+    channel_id = _try_mode_based_fallback(app_config)
+    if channel_id:
+        return channel_id, None
+
+    # 7. Emergency fallback
+    logger.warning("CRITICAL: Channel ID could not be resolved from any source")
+    return "UNKNOWN", None

ciris_engine/logic/context/secrets_snapshot.py

@@ -0,0 +1,52 @@
+import logging
+from typing import Any, Dict, List
+
+from ciris_engine.logic.secrets.service import SecretsService
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+# Key for error metadata in the returned dictionary
+ERROR_KEY = "error"
+
+
+async def build_secrets_snapshot(secrets_service: SecretsService) -> JSONDict:
+    """Build secrets information for SystemSnapshot.
+
+    Returns a JSON-compatible dictionary with keys matching SystemSnapshot fields:
+    - detected_secrets: List[str]
+    - secrets_filter_version: int
+    - total_secrets_stored: int
+
+    When an error occurs, the payload includes an ``error`` key so downstream
+    consumers can distinguish between an empty dataset and a failure.
+    """
+    try:
+        # Get recent secrets (limit to last 10 for context)
+        all_secrets = await secrets_service.store.list_all_secrets()
+        recent_secrets = sorted(all_secrets, key=lambda s: s.created_at, reverse=True)[:10]
+
+        # Convert SecretReference objects to strings for SystemSnapshot compatibility
+        detected_secrets: List[str] = [str(s.uuid) for s in recent_secrets]
+
+        # Get filter version
+        filter_config = secrets_service.filter.get_filter_config()
+        filter_version = filter_config.version
+
+        # Get total count
+        total_secrets = len(all_secrets)
+
+        return {
+            "detected_secrets": detected_secrets,
+            "secrets_filter_version": filter_version,
+            "total_secrets_stored": total_secrets,
+        }
+
+    except Exception as e:  # pragma: no cover - defensive
+        logger.exception("Error building secrets snapshot")
+        return {
+            "detected_secrets": [],
+            "secrets_filter_version": 0,
+            "total_secrets_stored": 0,
+            ERROR_KEY: f"Failed to build secrets snapshot: {type(e).__name__}: {e}",
+        }

ciris_engine/logic/context/system_snapshot.py

@@ -0,0 +1,116 @@
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+from pydantic import BaseModel
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.secrets.service import SecretsService
+from ciris_engine.logic.services.memory_service import LocalGraphMemoryService
+from ciris_engine.logic.utils import GraphQLContextProvider
+from ciris_engine.schemas.adapters.tools import ToolInfo
+from ciris_engine.schemas.runtime.models import Task
+from ciris_engine.schemas.runtime.system_context import ChannelContext, SystemSnapshot, UserProfile
+from ciris_engine.schemas.services.core.runtime import ServiceHealthStatus
+from ciris_engine.schemas.services.graph_core import GraphNode, GraphNodeAttributes, GraphScope, NodeType
+from ciris_engine.schemas.services.operations import MemoryQuery
+from ciris_engine.schemas.services.runtime_control import CircuitBreakerStatus
+
+from .secrets_snapshot import build_secrets_snapshot
+from .system_snapshot_helpers import (
+    _build_current_task_summary,
+    _collect_adapter_channels,
+    _collect_available_tools,
+    _collect_resource_alerts,
+    _collect_service_health,
+    _enrich_user_profiles,
+    _extract_agent_identity,
+    _extract_thought_summary,
+    _extract_user_ids_from_context,
+    _get_continuity_summary,
+    _get_localized_times,
+    _get_recent_tasks,
+    _get_secrets_data,
+    _get_shutdown_context,
+    _get_telemetry_summary,
+    _get_top_tasks,
+    _resolve_channel_context,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def json_serial(obj: Any) -> Any:
+    """JSON serializer for objects not serializable by default json code"""
+    if hasattr(obj, "isoformat"):
+        return obj.isoformat()
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump()
+    return str(obj)
+
+
+async def build_system_snapshot(
+    task: Optional[Task],
+    thought: Any,
+    resource_monitor: Any,  # REQUIRED - mission critical system
+    memory_service: Optional[LocalGraphMemoryService] = None,
+    graphql_provider: Optional[GraphQLContextProvider] = None,
+    telemetry_service: Optional[Any] = None,
+    secrets_service: Optional[SecretsService] = None,
+    runtime: Optional[Any] = None,
+    service_registry: Optional[Any] = None,
+    time_service: Any = None,  # REQUIRED - will fail fast and loud if None
+) -> SystemSnapshot:
+    """
+    DEPRECATED: Legacy wrapper for backwards compatibility.
+
+    This function is now a thin wrapper around the unified batch snapshot builder.
+    All production code should use build_system_snapshot_with_batch directly or
+    go through ContextBuilder.build_system_snapshot().
+
+    The unified batch approach:
+    - Creates minimal batch context on-demand for single thoughts
+    - Uses pre-fetched batch context for batch processing
+    - Ensures consistent user enrichment across all code paths
+    - Eliminates code duplication between batch and single-thought processing
+
+    This wrapper exists only for test compatibility and will be removed in a
+    future version once all tests are updated.
+    """
+    from .batch_context import build_system_snapshot_with_batch
+
+    logger.debug("[LEGACY WRAPPER] build_system_snapshot called - redirecting to unified batch builder")
+
+    # Redirect to unified batch builder (will create minimal batch context on-demand)
+    snapshot = await build_system_snapshot_with_batch(
+        task=task,
+        thought=thought,
+        batch_data=None,  # Will create minimal batch context on-demand
+        memory_service=memory_service,
+        graphql_provider=graphql_provider,
+        time_service=time_service,
+        secrets_service=secrets_service,
+        service_registry=service_registry,
+        resource_monitor=resource_monitor,
+        telemetry_service=telemetry_service,
+        runtime=runtime,
+    )
+
+    # Log context building statistics (for test compatibility)
+    if snapshot.user_profiles:
+        user_profiles_json = json.dumps([p.model_dump() for p in snapshot.user_profiles], default=json_serial)
+        user_profiles_bytes = len(user_profiles_json.encode("utf-8"))
+        logger.info(
+            f"[CONTEXT BUILD] User Profiles queried: {len(snapshot.user_profiles)} profiles, {user_profiles_bytes} bytes added to context"
+        )
+
+    # Log final snapshot size
+    snapshot_json = snapshot.model_dump_json()
+    snapshot_bytes = len(snapshot_json.encode("utf-8"))
+    if snapshot.channel_context is None:
+        logger.warning(f"[CONTEXT BUILD] System Snapshot built with {snapshot_bytes} bytes total (no channel context)")
+    else:
+        logger.info(f"[CONTEXT BUILD] System Snapshot built with {snapshot_bytes} bytes total")
+
+    return snapshot