ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/utils/channel_utils.py

@@ -0,0 +1,75 @@
+"""Utilities for channel context management."""
+
+from typing import Optional, Union
+
+from ciris_engine.schemas.runtime.system_context import ChannelContext
+
+
+def create_channel_context(
+    channel_id: Union[str, ChannelContext, None],
+    channel_name: Optional[str] = None,
+    channel_type: Optional[str] = None,
+) -> Optional[ChannelContext]:
+    """
+    Create a ChannelContext from various inputs.
+
+    Args:
+        channel_id: Channel ID string or existing ChannelContext
+        channel_name: Human-readable channel name
+        channel_type: Type of channel (discord, cli, api, etc.)
+
+    Returns:
+        ChannelContext instance or None if no valid input
+    """
+    if channel_id is None:
+        return None
+
+    if isinstance(channel_id, ChannelContext):
+        return channel_id
+
+    # Must be a string at this point
+    channel_id_str = channel_id
+
+    # Infer channel type from ID patterns if not provided
+    if channel_type is None:
+        if channel_id_str.startswith("cli_") or channel_id_str.startswith("cli-"):
+            channel_type = "cli"
+        elif channel_id_str.startswith("api_") or channel_id_str.startswith("api-"):
+            channel_type = "api"
+        elif channel_id_str.startswith("discord_"):
+            channel_type = "discord"
+        elif channel_id_str.startswith("reddit:"):
+            channel_type = "reddit"
+        elif channel_id_str.isdigit() and len(channel_id_str) >= 17:  # Discord IDs are 17-19 digits
+            channel_type = "discord"
+        else:
+            channel_type = "unknown"
+
+    from datetime import datetime, timezone
+
+    return ChannelContext(
+        channel_id=channel_id_str,
+        channel_name=channel_name,
+        channel_type=channel_type,
+        created_at=datetime.now(timezone.utc),
+        is_private=False,
+        is_active=True,
+    )
+
+
+def extract_channel_id(channel_context: Optional[Union[str, ChannelContext]]) -> Optional[str]:
+    """
+    Extract channel ID from either a string or ChannelContext.
+
+    Args:
+        channel_context: Channel ID string or ChannelContext instance
+
+    Returns:
+        Channel ID string or None
+    """
+    if channel_context is None:
+        return None
+    if isinstance(channel_context, str):
+        return channel_context
+    # Must be ChannelContext at this point
+    return channel_context.channel_id

ciris_engine/logic/utils/consent/__init__.py

@@ -0,0 +1 @@
+"""Consent utilities module."""

ciris_engine/logic/utils/consent/partnership_utils.py

@@ -0,0 +1,172 @@
+"""
+Partnership utilities for Consensual Evolution Protocol.
+
+Helper functions for managing bilateral consent for PARTNERED stream upgrades.
+Creates tasks that the agent can approve through thought system (REJECT/DEFER/TASK_COMPLETE).
+
+Note: This is NOT a handler - it's a utility class used by ConsentService.
+"""
+
+import logging
+import uuid
+from typing import Any, Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.runtime.enums import TaskStatus
+from ciris_engine.schemas.runtime.models import Task, TaskContext
+
+logger = logging.getLogger(__name__)
+
+
+class PartnershipRequestHandler:
+    """Utility class for creating and checking partnership consent tasks.
+
+    This is NOT a handler - it's a helper used by ConsentService to create
+    tasks that actual handlers (REJECT/DEFER/TASK_COMPLETE) will process.
+    """
+
+    def __init__(self, time_service: TimeServiceProtocol, auth_service: Optional[object] = None):
+        self.time_service = time_service
+        self.auth_service = auth_service
+
+    def create_partnership_task(
+        self,
+        user_id: str,
+        categories: list[str],
+        reason: Optional[str] = None,
+        channel_id: Optional[str] = None,
+    ) -> Task:
+        """
+        Create a task for the agent to approve/reject partnership request.
+
+        Similar to shutdown tasks, the agent can:
+        - TASK_COMPLETE: Accept partnership
+        - REJECT: Decline partnership with reason
+        - DEFER: Request more information or delay decision
+
+        Args:
+            user_id: User requesting partnership
+            categories: Consent categories requested
+            reason: User's reason for requesting partnership
+            channel_id: Channel where request originated
+
+        Returns:
+            Created task for agent processing
+        """
+        now_iso = self.time_service.now().isoformat()
+        task_id = f"partnership_{user_id}_{uuid.uuid4().hex[:8]}"
+
+        # Format categories for description
+        category_str = ", ".join(categories) if categories else "all categories"
+
+        # Build task description
+        description = f"Partnership request from {user_id} for {category_str}."
+        if reason:
+            description += f" Reason: {reason}"
+        description += (
+            "\n\nThis is a request for PARTNERED consent - mutual growth agreement. "
+            "You may:\n"
+            "- Accept (TASK_COMPLETE): Form partnership for mutual learning\n"
+            "- Reject (REJECT): Decline with reason\n"
+            "- Defer (DEFER): Request more information or time to consider"
+        )
+
+        # Create task context
+        context = TaskContext(
+            channel_id=channel_id or "",
+            user_id=user_id,
+            correlation_id=f"consent_partnership_{uuid.uuid4().hex[:8]}",
+            parent_task_id=None,
+        )
+
+        # Create the task
+        task = Task(
+            task_id=task_id,
+            channel_id=channel_id or "",
+            description=description,
+            priority=5,  # Medium priority
+            status=TaskStatus.ACTIVE,
+            created_at=now_iso,
+            updated_at=now_iso,
+            context=context,
+            parent_task_id=None,
+        )
+
+        # Add task directly to persistence (like observers do)
+        persistence.add_task(task)
+        logger.info(f"Created partnership request task {task_id} for user {user_id}")
+
+        return task
+
+    def check_task_outcome(self, task_id: str) -> tuple[str, Optional[str]]:
+        """
+        Check the outcome of a partnership request task.
+
+        Returns:
+            Tuple of (outcome, reason) where outcome is:
+            - "pending": Still being processed
+            - "accepted": Partnership approved (TASK_COMPLETE)
+            - "rejected": Partnership declined (REJECT action)
+            - "deferred": More information needed (DEFER action)
+            - "failed": Task failed for technical reasons
+        """
+        task = persistence.get_task_by_id(task_id)
+        if not task:
+            return ("failed", "Task not found")
+
+        # Map simple status cases
+        outcome = self._map_task_status(task.status)
+        if outcome[0] != "check_thoughts":
+            return outcome
+
+        # For FAILED status, check thoughts for actual outcome
+        return self._check_thoughts_for_outcome(task_id)
+
+    def _map_task_status(self, status: TaskStatus) -> tuple[str, Optional[str]]:
+        """Map task status to outcome, returning special marker for complex cases."""
+        status_map = {
+            TaskStatus.PENDING: ("pending", None),
+            TaskStatus.ACTIVE: ("pending", None),
+            TaskStatus.COMPLETED: ("accepted", "Partnership approved by agent"),
+            TaskStatus.REJECTED: ("rejected", "Request was rejected"),
+            TaskStatus.DEFERRED: ("deferred", "Request was deferred"),
+            TaskStatus.FAILED: ("check_thoughts", None),  # Special marker
+        }
+        return status_map.get(status, ("pending", None))
+
+    def _check_thoughts_for_outcome(self, task_id: str) -> tuple[str, Optional[str]]:
+        """Check thoughts to determine outcome for failed tasks."""
+        thoughts = persistence.get_thoughts_by_task_id(task_id)
+        if not thoughts:
+            return ("failed", "Task failed without clear reason")
+
+        for thought in reversed(thoughts):
+            outcome = self._extract_action_from_thought(thought)
+            if outcome:
+                return outcome
+
+        return ("failed", "Task failed without clear reason")
+
+    def _extract_action_from_thought(self, thought: Any) -> Optional[tuple[str, str]]:
+        """Extract action outcome from a single thought."""
+        if not hasattr(thought, "final_action") or not thought.final_action:
+            return None
+
+        action = thought.final_action
+
+        if action.action_type == "REJECT":
+            reason = self._extract_reason_from_params(action.action_params, "No reason provided")
+            return ("rejected", reason)
+
+        if action.action_type == "DEFER":
+            reason = self._extract_reason_from_params(action.action_params, "More information needed")
+            return ("deferred", reason)
+
+        return None
+
+    def _extract_reason_from_params(self, params: Any, default: str) -> str:
+        """Extract reason from action params safely."""
+        if isinstance(params, dict):
+            return str(params.get("reason", default))
+        return default

ciris_engine/logic/utils/constants.py

@@ -0,0 +1,92 @@
+import logging
+from pathlib import Path
+
+from ciris_engine.logic.config.env_utils import get_env_var
+from ciris_engine.logic.utils.path_resolution import is_android
+
+logger = logging.getLogger(__name__)
+
+# DEFAULT_WA removed - use WA_USER_IDS for Discord user IDs instead
+WA_USER_IDS = get_env_var("WA_USER_IDS", "537080239679864862")  # Comma-separated list of WA user IDs
+
+DISCORD_CHANNEL_ID = get_env_var("DISCORD_CHANNEL_ID")
+DISCORD_DEFERRAL_CHANNEL_ID = get_env_var("DISCORD_DEFERRAL_CHANNEL_ID")
+API_CHANNEL_ID = get_env_var("API_CHANNEL_ID")
+API_DEFERRAL_CHANNEL_ID = get_env_var("API_DEFERRAL_CHANNEL_ID")
+WA_API_USER = get_env_var("WA_API_USER", "somecomputerguy")  # API username for WA
+
+
+def _load_platform_guide(base_path: Path) -> str:
+    """Load the appropriate runtime guide based on platform.
+
+    On Android, tries to load CIRIS_COMPREHENSIVE_GUIDE_ANDROID.md first,
+    falls back to the standard guide if not available.
+
+    Args:
+        base_path: The base directory containing the guide files
+
+    Returns:
+        The guide content as a string, or empty string if not found
+    """
+    guide_files = []
+
+    # Platform-specific guide takes priority
+    if is_android():
+        guide_files.append(base_path / "CIRIS_COMPREHENSIVE_GUIDE_ANDROID.md")
+        logger.debug("Android platform detected, will try Android-specific guide first")
+
+    # Standard guide as fallback
+    guide_files.append(base_path / "CIRIS_COMPREHENSIVE_GUIDE.md")
+
+    for guide_path in guide_files:
+        try:
+            with open(guide_path, "r", encoding="utf-8") as f:
+                logger.debug("Loaded runtime guide from: %s", guide_path)
+                return f.read()
+        except FileNotFoundError:
+            continue
+        except Exception as exc:
+            logger.debug("Could not load guide from %s: %s", guide_path, exc)
+            continue
+
+    logger.debug("No comprehensive guide found (development-only file)")
+    return ""
+
+
+# Load covenant text from package data using importlib.resources
+# This works for both development (editable install) and pip-installed packages
+try:
+    try:
+        # Python 3.9+ - preferred method
+        from importlib.resources import files
+
+        covenant_content = files("ciris_engine.data").joinpath("covenant_1.0b.txt").read_text(encoding="utf-8")
+    except ImportError:
+        # Python 3.7-3.8 fallback
+        from importlib.resources import read_text
+
+        covenant_content = read_text("ciris_engine.data", "covenant_1.0b.txt", encoding="utf-8")
+
+    # Try to append platform-appropriate comprehensive guide
+    _GUIDE_BASE_PATH = Path(__file__).resolve().parents[3]
+    guide_content = _load_platform_guide(_GUIDE_BASE_PATH)
+
+    if guide_content:
+        COVENANT_TEXT = covenant_content + "\n\n---\n\n" + guide_content
+    else:
+        COVENANT_TEXT = covenant_content
+
+except Exception as exc:
+    logger.warning("Could not load covenant text from package data: %s", exc)
+    COVENANT_TEXT = ""
+
+NEED_MEMORY_METATHOUGHT = "need_memory_metathought"
+
+ENGINE_OVERVIEW_TEMPLATE = (
+    "ENGINE OVERVIEW: The CIRIS Engine processes a task through a sequence of "
+    "Thoughts. Each handler action except TASK_COMPLETE enqueues a new Thought "
+    "for further processing. Selecting TASK_COMPLETE marks the task closed and "
+    "no new Thought is generated."
+)
+
+DEFAULT_NUM_ROUNDS = None

ciris_engine/logic/utils/context_utils.py

@@ -0,0 +1,145 @@
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+from ciris_engine.logic.utils.jsondict_helpers import get_bool
+from ciris_engine.protocols.services import TimeServiceProtocol
+from ciris_engine.schemas.types import JSONDict
+
+if TYPE_CHECKING:
+    from ciris_engine.schemas.processors.core import ConscienceApplicationResult
+
+from ciris_engine.logic.utils.channel_utils import create_channel_context
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType
+
+logger = logging.getLogger(__name__)
+
+
+def build_dispatch_context(
+    thought: Any,
+    time_service: TimeServiceProtocol,
+    task: Optional[Any] = None,
+    app_config: Optional[Any] = None,
+    round_number: Optional[int] = None,
+    extra_context: Optional[JSONDict] = None,
+    conscience_result: Optional["ConscienceApplicationResult"] = None,
+    action_type: Optional[Any] = None,
+) -> DispatchContext:
+    """
+    Build a type-safe dispatch context for thought processing.
+
+    Args:
+        thought: The thought object being processed
+        time_service: Time service for timestamps
+        task: Optional task associated with the thought
+        app_config: Optional app configuration for determining origin service
+        round_number: Optional round number for processing
+        extra_context: Optional additional runtime context (wa_id, correlation_id, etc.)
+        conscience_result: Optional conscience evaluation results
+        action_type: Optional action type override
+
+    Returns:
+        DispatchContext object with all relevant fields populated
+    """
+
+    # Core identification
+    thought_id = getattr(thought, "thought_id", None)
+    source_task_id = getattr(thought, "source_task_id", None)
+
+    # Determine origin service
+    if app_config and hasattr(app_config, "agent_mode"):
+        origin_service = "CLI" if app_config.agent_mode.lower() == "cli" else "discord"
+    else:
+        origin_service = "discord"
+
+    # Extract task context
+    channel_context = None
+    author_id = None
+    author_name = None
+    task_id = None
+
+    # First try to get context from thought (most specific)
+    if hasattr(thought, "context"):
+        if hasattr(thought.context, "initial_task_context") and thought.context.initial_task_context:
+            channel_context = thought.context.initial_task_context.channel_context
+            author_id = thought.context.initial_task_context.author_id
+            author_name = thought.context.initial_task_context.author_name
+
+    # If not found in thought, check task
+    if channel_context is None and task:
+        task_id = getattr(task, "task_id", None)
+        if hasattr(task, "context"):
+            # Debug logging
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.info(
+                f"Processing task {task_id} context type: {type(task.context)}, attributes: {dir(task.context) if task.context else 'None'}"
+            )
+
+            # Handle TaskContext (the correct type for task.context)
+            if hasattr(task.context, "channel_id"):
+                # TaskContext object from models.py
+                channel_id = task.context.channel_id
+                if channel_id:
+                    channel_context = create_channel_context(channel_id)
+                    author_id = task.context.user_id
+                    author_name = None  # TaskContext doesn't have author_name
+            else:
+                logger.error(
+                    f"Task {task_id} has invalid context type: {type(task.context)}. Expected TaskContext with channel_id."
+                )
+
+    # Check extra_context for channel_id as fallback
+    if channel_context is None and extra_context:
+        channel_id = extra_context.get("channel_id")
+        if channel_id and isinstance(channel_id, str):
+            channel_context = create_channel_context(channel_id)
+
+    # Channel context is required
+    if channel_context is None:
+        raise ValueError(
+            f"No channel context found for thought {thought_id}. Adapters must provide channel_id in task context."
+        )
+
+    # Extract additional fields from extra_context
+    wa_id = None
+    wa_authorized = False
+    correlation_id = None
+    handler_name = None
+    event_summary = None
+
+    if extra_context:
+        wa_id = extra_context.get("wa_id")
+        wa_authorized = get_bool(extra_context, "wa_authorized", False)  # Type-safe bool extraction
+        correlation_id = extra_context.get("correlation_id")
+        handler_name = extra_context.get("handler_name")
+        event_summary = extra_context.get("event_summary")
+
+    # Create the DispatchContext object with defaults for None values
+    dispatch_context = DispatchContext(
+        # Core identification
+        channel_context=channel_context,
+        author_id=author_id or "unknown",
+        author_name=author_name or "Unknown",
+        # Service references
+        origin_service=origin_service,
+        handler_name=handler_name or "unknown_handler",
+        # Action context
+        action_type=action_type or HandlerActionType.SPEAK,
+        thought_id=thought_id or "",
+        task_id=task_id or "",
+        source_task_id=source_task_id or "",
+        # Event details
+        event_summary=event_summary or "No summary provided",
+        event_timestamp=time_service.now_iso() + "Z",
+        # Additional context
+        wa_id=wa_id,
+        wa_authorized=wa_authorized,
+        correlation_id=correlation_id or f"ctx_{time_service.timestamp()}",
+        # conscience results (None for terminal actions)
+        # Extract ConscienceResult from ConscienceApplicationResult if needed
+        conscience_failure_context=None,
+    )
+
+    return dispatch_context