ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/handlers/external/speak_handler.py

@@ -0,0 +1,250 @@
+import logging
+from typing import Optional, Set
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.infrastructure.handlers.base_handler import ActionHandlerDependencies, BaseActionHandler
+from ciris_engine.logic.infrastructure.handlers.exceptions import FollowUpCreationError
+from ciris_engine.logic.infrastructure.handlers.helpers import create_follow_up_thought
+from ciris_engine.logic.utils.channel_utils import extract_channel_id
+from ciris_engine.schemas.actions import SpeakParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+
+logger = logging.getLogger(__name__)
+
+# Known adapter prefixes for channel routing
+KNOWN_ADAPTER_PREFIXES: Set[str] = {"api_", "discord_", "cli_", "ws:", "reddit_"}
+
+
+def _has_valid_adapter_prefix(channel_id: str) -> bool:
+    """Check if channel_id has a known adapter prefix."""
+    return any(channel_id.startswith(prefix) for prefix in KNOWN_ADAPTER_PREFIXES)
+
+
+def _normalize_channel_id(channel_id: str, thought: Thought) -> str:
+    """
+    Normalize a channel_id to ensure it has a valid adapter prefix.
+
+    If the channel_id doesn't have a valid prefix (e.g., just a user_id like "google:123"),
+    try to find the correct prefix from the thought/task context, or default to "api_".
+
+    Args:
+        channel_id: The channel_id to normalize
+        thought: The thought context for looking up the original channel
+
+    Returns:
+        Normalized channel_id with adapter prefix
+    """
+    if _has_valid_adapter_prefix(channel_id):
+        return channel_id
+
+    # Channel doesn't have a valid prefix - try to get the correct one from context
+    logger.info(f"SPEAK: channel_id '{channel_id}' missing adapter prefix, attempting to normalize")
+
+    # Check if the task has a channel_id that matches (with prefix)
+    if thought.source_task_id:
+        task = persistence.get_task_by_id(thought.source_task_id)
+        if task and task.channel_id:
+            # Check if task's channel_id ends with the provided channel_id
+            # e.g., task.channel_id = "api_google:123" and channel_id = "google:123"
+            if task.channel_id.endswith(channel_id):
+                logger.info(f"SPEAK: Found matching task channel_id '{task.channel_id}' for '{channel_id}'")
+                return task.channel_id
+
+    # Default: prepend "api_" for API-originated messages
+    normalized = f"api_{channel_id}"
+    logger.info(f"SPEAK: Normalized channel_id to '{normalized}' (prepended api_)")
+    return normalized
+
+
+def _build_speak_error_context(params: SpeakParams, thought_id: str, error_type: str = "notification_failed") -> str:
+    """Build a descriptive error context string for speak failures."""
+    # Use attribute access for content if it's a GraphNode
+    content_str = params.content
+    if hasattr(params.content, "value"):
+        content_str = getattr(params.content, "value", str(params.content))
+    elif hasattr(params.content, "__str__"):
+        content_str = str(params.content)
+    channel_id = extract_channel_id(params.channel_context) or "unknown"
+    error_contexts = {
+        "notification_failed": f"Failed to send notification to channel '{channel_id}' with content: '{content_str[:100]}{'...' if len(content_str) > 100 else ''}'",
+        "channel_unavailable": f"Channel '{channel_id}' is not available or accessible",
+        "content_rejected": f"Content was rejected by the communication service: '{content_str[:100]}{'...' if len(content_str) > 100 else ''}'",
+        "service_timeout": f"Communication service timed out while sending to channel '{channel_id}'",
+        "unknown": f"Unknown error occurred while speaking to channel '{channel_id}'",
+    }
+
+    base_context = error_contexts.get(error_type, error_contexts["unknown"])
+    return f"Thought {thought_id}: {base_context}"
+
+
+class SpeakHandler(BaseActionHandler):
+    def __init__(self, dependencies: ActionHandlerDependencies) -> None:
+        super().__init__(dependencies)
+
+    async def handle(
+        self,
+        result: ActionSelectionDMAResult,  # Updated to v1 result schema
+        thought: Thought,
+        dispatch_context: DispatchContext,
+    ) -> Optional[str]:
+        thought_id = thought.thought_id
+        start_time = self.time_service.now()
+
+        # Create trace correlation for handler execution
+        self._create_trace_correlation(dispatch_context, HandlerActionType.SPEAK)
+
+        try:
+            # Auto-decapsulate any secrets in the action parameters
+            processed_result = await self._decapsulate_secrets_in_params(result, "speak", thought.thought_id)
+
+            # Debug: Check what channel_context we received
+            if hasattr(processed_result.action_parameters, "get"):
+                channel_ctx = processed_result.action_parameters.get("channel_context", "None")
+                logger.info(f"SPEAK: Received action_parameters dict with channel_context: {channel_ctx}")
+                if hasattr(channel_ctx, "keys"):
+                    logger.info(f"SPEAK: channel_context dict contains: {channel_ctx}")
+
+            params: SpeakParams = self._validate_and_convert_params(processed_result.action_parameters, SpeakParams)
+        except Exception as e:
+            await self._handle_error(HandlerActionType.SPEAK, dispatch_context, thought_id, e)
+            persistence.update_thought_status(
+                thought_id=thought_id,
+                status=ThoughtStatus.FAILED,
+                final_action=result,
+            )
+            follow_up_text = f"SPEAK action failed for thought {thought_id}. Reason: {e}"
+            # Update trace correlation with failure
+            self._update_trace_correlation(False, f"Parameter validation failed: {str(e)}")
+            try:
+                fu = create_follow_up_thought(parent=thought, time_service=self.time_service, content=follow_up_text)
+                # Simple: ensure channel_id is in the thought context
+                if fu.context and not fu.context.channel_id:
+                    # Extract channel_id from params.channel_context if available
+                    extracted_channel_id = extract_channel_id(params.channel_context) or "unknown"
+                    fu.context.channel_id = extracted_channel_id
+                persistence.add_thought(fu)
+                return fu.thought_id
+            except Exception as fe:
+                await self._handle_error(HandlerActionType.SPEAK, dispatch_context, thought_id, fe)
+                raise FollowUpCreationError from fe
+
+        # Get channel ID - first check params.channel_id, then params.channel_context, then fall back to thought/task context
+        channel_id = None
+
+        # First, check if channel_id is directly provided in params (from LLM)
+        if params.channel_id:
+            channel_id = params.channel_id
+            logger.info(f"SPEAK: Using channel_id '{channel_id}' from params.channel_id")
+
+        # Second, check if channel is specified in params.channel_context
+        elif params.channel_context:
+            channel_id = extract_channel_id(params.channel_context)
+            if channel_id:
+                logger.info(f"SPEAK: Using channel_id '{channel_id}' from params.channel_context")
+
+        # Fall back to thought/task context if not in params
+        if not channel_id:
+            channel_id = self._get_channel_id(thought, dispatch_context)
+            if channel_id:
+                logger.info(f"SPEAK: Using channel_id '{channel_id}' from thought/task context")
+
+        if not channel_id:
+            logger.error(f"CRITICAL: No channel_id found in params or thought {thought_id} context")
+            raise ValueError(f"Channel ID is required for SPEAK action - none found in params or thought {thought_id}")
+
+        # Normalize channel_id to ensure it has a valid adapter prefix
+        # This handles cases where the LLM provides a user_id without the adapter prefix
+        channel_id = _normalize_channel_id(channel_id, thought)
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        # Extract string from GraphNode for notification
+        content_str = (
+            params.content.attributes.get("text", str(params.content))
+            if hasattr(params.content, "attributes")
+            else str(params.content)
+        )
+        success = await self._send_notification(channel_id, content_str)
+
+        final_thought_status = ThoughtStatus.COMPLETED if success else ThoughtStatus.FAILED
+
+        # Build error context if needed
+        assert isinstance(params, SpeakParams)  # Type assertion - validated earlier
+        _follow_up_error_context = None if success else _build_speak_error_context(params, thought_id)
+
+        # Get the actual task content instead of just the ID
+        task = persistence.get_task_by_id(thought.source_task_id)
+        _task_description = task.description if task else f"task {thought.source_task_id}"
+
+        # Create correlation for tracking action completion
+        import uuid
+
+        from ciris_engine.schemas.telemetry.core import (
+            ServiceCorrelation,
+            ServiceCorrelationStatus,
+            ServiceRequestData,
+            ServiceResponseData,
+        )
+
+        now = self.time_service.now()
+
+        # Create proper request data
+        request_data = ServiceRequestData(
+            service_type="communication",
+            method_name="send_message",
+            thought_id=thought_id,
+            task_id=thought.source_task_id,
+            channel_id=channel_id,
+            parameters={"content": str(params.content)},
+            request_timestamp=now,
+        )
+
+        # Create proper response data
+        response_data = ServiceResponseData(
+            success=success,
+            result_summary=f"Message {'sent' if success else 'failed'} to channel {channel_id}",
+            execution_time_ms=(now - start_time).total_seconds() * 1000.0,
+            response_timestamp=now,
+        )
+
+        correlation = ServiceCorrelation(
+            correlation_id=str(uuid.uuid4()),
+            service_type="handler",
+            handler_name="SpeakHandler",
+            action_type="speak_action",
+            request_data=request_data,
+            response_data=response_data,
+            status=ServiceCorrelationStatus.COMPLETED if success else ServiceCorrelationStatus.FAILED,
+            created_at=now,
+            updated_at=now,
+            timestamp=now,  # Required for TSDB indexing
+        )
+        persistence.add_correlation(correlation, self.time_service)
+
+        follow_up_text = (
+            f"CIRIS_FOLLOW_UP_THOUGHT: Message sent to channel {channel_id}. "
+            "If this task is complete, use TASK_COMPLETE. New user messages create new tasks automatically."
+            if success
+            else f"CIRIS_FOLLOW_UP_THOUGHT: SPEAK action failed for thought {thought_id}."
+        )
+
+        # Use centralized method for both success and failure cases
+        follow_up_thought_id = self.complete_thought_and_create_followup(
+            thought=thought, follow_up_content=follow_up_text, action_result=result, status=final_thought_status
+        )
+
+        if not follow_up_thought_id:
+            await self._handle_error(
+                HandlerActionType.SPEAK, dispatch_context, thought_id, Exception("Failed to create follow-up thought")
+            )
+            raise FollowUpCreationError("Failed to create follow-up thought")
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        # Update trace correlation with success
+        self._update_trace_correlation(success, f"Message {'sent' if success else 'failed'} to channel {channel_id}")
+
+        return follow_up_thought_id

ciris_engine/logic/handlers/external/tool_handler.py

@@ -0,0 +1,148 @@
+import logging
+import uuid
+from typing import Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.infrastructure.handlers.base_handler import BaseActionHandler
+from ciris_engine.logic.infrastructure.handlers.exceptions import FollowUpCreationError
+from ciris_engine.schemas.actions import ToolParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+from ciris_engine.schemas.types import JSONDict
+
+logger = logging.getLogger(__name__)
+
+
+class ToolHandler(BaseActionHandler):
+    TOOL_RESULT_TIMEOUT = 30
+
+    async def handle(
+        self, result: ActionSelectionDMAResult, thought: Thought, dispatch_context: DispatchContext
+    ) -> Optional[str]:
+        thought_id = thought.thought_id
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+        final_thought_status = ThoughtStatus.COMPLETED
+        follow_up_content_key_info = f"TOOL action for thought {thought_id}"
+        action_performed_successfully = False
+        new_follow_up = None
+
+        params: Optional[ToolParams] = None
+        try:
+            # Debug logging
+            self.logger.debug(f"Raw result.action_parameters: {result.action_parameters}")
+            self.logger.debug(f"Type: {type(result.action_parameters)}")
+
+            processed_result = await self._decapsulate_secrets_in_params(result, "tool", thought_id)
+
+            self.logger.debug(f"After decapsulation: {processed_result.action_parameters}")
+
+            params = self._validate_and_convert_params(processed_result.action_parameters, ToolParams)
+        except Exception as e:
+            await self._handle_error(HandlerActionType.TOOL, dispatch_context, thought_id, e)
+            final_thought_status = ThoughtStatus.FAILED
+            follow_up_content_key_info = f"TOOL action failed: {e}"
+            params = None
+
+        # Tool handler will use the tool bus to execute tools
+        if not isinstance(params, ToolParams):
+            self.logger.error(
+                f"TOOL action params are not ToolParams model. Type: {type(params)}. Thought ID: {thought_id}"
+            )
+            final_thought_status = ThoughtStatus.FAILED
+            follow_up_content_key_info = (
+                f"TOOL action failed: Invalid parameters type ({type(params)}) for thought {thought_id}."
+            )
+        else:
+            _correlation_id = str(uuid.uuid4())
+            try:
+                # Debug logging
+                self.logger.info(f"[TOOL_HANDLER] Executing tool: name={params.name}, parameters={params.parameters}")
+                self.logger.info(f"[TOOL_HANDLER] Parameters type: {type(params.parameters)}")
+
+                # If channel_id is provided in action params but not in tool parameters, add it
+                # This helps tools that need channel context
+                from typing import cast
+
+                tool_params = dict(params.parameters)
+                if params.channel_id and "channel_id" not in tool_params:
+                    tool_params["channel_id"] = params.channel_id
+                    self.logger.debug(f"Added channel_id {params.channel_id} to tool parameters")
+
+                # Add task_id for tools that need billing interaction_id (e.g., web_search)
+                if thought.source_task_id and "task_id" not in tool_params:
+                    tool_params["task_id"] = thought.source_task_id
+                    self.logger.debug(f"Added task_id {thought.source_task_id} to tool parameters")
+
+                # Use the tool bus to execute the tool
+                self.logger.info(f"[TOOL_HANDLER] Calling bus_manager.tool.execute_tool for '{params.name}'...")
+                tool_result = await self.bus_manager.tool.execute_tool(
+                    tool_name=params.name, parameters=cast(JSONDict, tool_params), handler_name=self.__class__.__name__
+                )
+                self.logger.info(
+                    f"[TOOL_HANDLER] Tool result: success={tool_result.success}, status={tool_result.status}, error={tool_result.error}"
+                )
+                # Log full tool result data for debugging
+                if tool_result.data:
+                    import json
+
+                    try:
+                        data_str = json.dumps(tool_result.data, indent=2, default=str)
+                        self.logger.info(f"[TOOL_HANDLER] Tool result data:\n{data_str}")
+                    except Exception:
+                        self.logger.info(f"[TOOL_HANDLER] Tool result data: {tool_result.data}")
+
+                # tool_result is now ToolExecutionResult per protocol
+                if tool_result.success:
+                    action_performed_successfully = True
+                    follow_up_content_key_info = (
+                        f"Tool '{params.name}' executed successfully. Result: {tool_result.data or 'No result data'}"
+                    )
+                    self.logger.info(f"[TOOL_HANDLER] Tool '{params.name}' SUCCESS")
+                else:
+                    final_thought_status = ThoughtStatus.FAILED
+                    follow_up_content_key_info = f"Tool '{params.name}' failed: {tool_result.error or 'Unknown error'}"
+                    self.logger.error(f"[TOOL_HANDLER] Tool '{params.name}' FAILED: {tool_result.error}")
+            except Exception as e_tool:
+                self.logger.error(
+                    f"[TOOL_HANDLER] EXCEPTION executing tool '{params.name}': {type(e_tool).__name__}: {e_tool}",
+                    exc_info=True,
+                )
+                await self._handle_error(HandlerActionType.TOOL, dispatch_context, thought_id, e_tool)
+                final_thought_status = ThoughtStatus.FAILED
+                follow_up_content_key_info = f"TOOL {params.name} execution failed: {str(e_tool)}"
+
+        follow_up_text = ""
+        if action_performed_successfully and isinstance(params, ToolParams):
+            follow_up_text = f"CIRIS_FOLLOW_UP_THOUGHT: TOOL action {params.name} executed for thought {thought_id}. Info: {follow_up_content_key_info}. Awaiting tool results or next steps. If task complete, use TASK_COMPLETE."
+        else:
+            follow_up_text = f"CIRIS_FOLLOW_UP_THOUGHT: TOOL action failed for thought {thought_id}. Reason: {follow_up_content_key_info}. Review and determine next steps."
+
+        # If tool failed, update thought status to FAILED before creating follow-up
+        if final_thought_status == ThoughtStatus.FAILED:
+            persistence.update_thought_status(thought.thought_id, ThoughtStatus.FAILED)
+            # Create follow-up manually since complete_thought_and_create_followup sets to COMPLETED
+            from ciris_engine.logic.infrastructure.handlers.helpers import create_follow_up_thought
+            from ciris_engine.schemas.runtime.enums import ThoughtType
+
+            follow_up = create_follow_up_thought(
+                parent=thought,
+                time_service=self.time_service,
+                content=follow_up_text,
+                thought_type=ThoughtType.FOLLOW_UP,
+            )
+            persistence.add_thought(follow_up)
+            follow_up_id: Optional[str] = follow_up.thought_id
+        else:
+            # Use centralized method for successful cases
+            follow_up_id = self.complete_thought_and_create_followup(
+                thought=thought, follow_up_content=follow_up_text, action_result=result
+            )
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        if not follow_up_id:
+            raise FollowUpCreationError("Failed to create follow-up thought")
+
+        return follow_up_id

ciris_engine/logic/handlers/memory/__init__.py

@@ -0,0 +1 @@
+"""Memory handlers module."""

ciris_engine/logic/handlers/memory/forget_handler.py

@@ -0,0 +1,107 @@
+import logging
+from typing import Any, Optional
+
+from pydantic import ValidationError
+
+from ciris_engine.logic.infrastructure.handlers.base_handler import BaseActionHandler
+from ciris_engine.logic.services.memory_service import MemoryOpStatus
+from ciris_engine.schemas.actions import ForgetParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+from ciris_engine.schemas.services.graph_core import GraphScope
+
+logger = logging.getLogger(__name__)
+
+
+class ForgetHandler(BaseActionHandler):
+    async def handle(
+        self, result: ActionSelectionDMAResult, thought: Thought, dispatch_context: DispatchContext
+    ) -> Optional[str]:
+        raw_params = result.action_parameters
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+        params = raw_params
+        if not isinstance(params, ForgetParams):
+            try:
+                # Try to convert from another Pydantic model
+                if hasattr(params, "model_dump"):
+                    params = ForgetParams(**params.model_dump())
+                else:
+                    # Should not happen if DMA is working correctly
+                    raise ValueError(f"Expected ForgetParams but got {type(params)}")
+            except (ValidationError, ValueError) as e:
+                logger.error(f"ForgetHandler: Invalid params dict: {e}")
+                follow_up_content = f"This is a follow-up thought from a FORGET action performed on parent task {thought.source_task_id}. FORGET action failed: Invalid parameters. {e}. If the task is now resolved, the next step may be to mark the parent task complete with COMPLETE_TASK."
+
+                # Use the proper method to complete thought and create follow-up
+                follow_up_id = self.complete_thought_and_create_followup(
+                    thought=thought,
+                    follow_up_content=follow_up_content,
+                    action_result=result,
+                    status=ThoughtStatus.FAILED,
+                )
+
+                # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+                return follow_up_id
+        if not self._can_forget(params, dispatch_context):
+            logger.info("ForgetHandler: Permission denied or WA required for forget operation. Creating deferral.")
+            follow_up_content = f"This is a follow-up thought from a FORGET action performed on parent task {thought.source_task_id}. FORGET action was not permitted. If the task is now resolved, the next step may be to mark the parent task complete with COMPLETE_TASK."
+
+            # Use the proper method to complete thought and create follow-up
+            follow_up_id = self.complete_thought_and_create_followup(
+                thought=thought, follow_up_content=follow_up_content, action_result=result, status=ThoughtStatus.FAILED
+            )
+
+            # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+            return follow_up_id
+        # Memory operations will use the memory bus
+
+        node = params.node
+        scope = node.scope
+        if scope in (GraphScope.IDENTITY, GraphScope.ENVIRONMENT) and not getattr(
+            dispatch_context, "wa_authorized", False
+        ):
+            follow_up_content = "FORGET action denied: WA authorization required"
+
+            # Use the proper method to complete thought and create follow-up
+            follow_up_id = self.complete_thought_and_create_followup(
+                thought=thought, follow_up_content=follow_up_content, action_result=result, status=ThoughtStatus.FAILED
+            )
+
+            # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+            return follow_up_id
+
+        forget_result = await self.bus_manager.memory.forget(node=node, handler_name=self.__class__.__name__)
+        await self._audit_forget_operation(params, dispatch_context, forget_result)
+        success = forget_result.status == MemoryOpStatus.OK
+
+        if success:
+            follow_up_content = f"CIRIS_FOLLOW_UP_THOUGHT: This is a follow-up thought from a FORGET action performed on parent task {thought.source_task_id}. Successfully forgot key '{node.id}' in scope {node.scope.value}. If the task is now resolved, the next step may be to mark the parent task complete with COMPLETE_TASK."
+        else:
+            follow_up_content = f"CIRIS_FOLLOW_UP_THOUGHT: This is a follow-up thought from a FORGET action performed on parent task {thought.source_task_id}. Failed to forget key '{node.id}' in scope {node.scope.value}. If the task is now resolved, the next step may be to mark the parent task complete with COMPLETE_TASK."
+
+        # Use the proper method to complete thought and create follow-up
+        follow_up_id = self.complete_thought_and_create_followup(
+            thought=thought,
+            follow_up_content=follow_up_content,
+            action_result=result,
+            status=ThoughtStatus.COMPLETED if success else ThoughtStatus.FAILED,
+        )
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        return follow_up_id
+
+    def _can_forget(self, params: ForgetParams, dispatch_context: DispatchContext) -> bool:
+        if hasattr(params, "node") and hasattr(params.node, "scope"):
+            scope = params.node.scope
+            if scope in (GraphScope.IDENTITY, GraphScope.ENVIRONMENT):
+                return getattr(dispatch_context, "wa_authorized", False)
+        return True
+
+    async def _audit_forget_operation(
+        self, params: ForgetParams, dispatch_context: DispatchContext, result: Any
+    ) -> None:
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+        pass