ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/persistence/models/graph.py

@@ -0,0 +1,362 @@
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Any, List, Optional
+
+from ciris_engine.logic.persistence.db import get_db_connection
+from ciris_engine.logic.persistence.db.dialect import get_adapter
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.services.graph_core import GraphEdge, GraphEdgeAttributes, GraphNode, GraphScope, NodeType
+
+logger = logging.getLogger(__name__)
+
+
+def parse_json_field(value: Any) -> Any:
+    """Parse JSON field from database.
+
+    PostgreSQL JSONB returns dict, SQLite returns string.
+    This function handles both cases.
+    """
+    if value is None:
+        return {}
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        return json.loads(value) if value else {}
+    return {}
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles datetime objects and Pydantic models."""
+
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        # Handle Pydantic models
+        if hasattr(obj, "model_dump"):
+            return obj.model_dump()
+        # Handle objects with dict() method
+        if hasattr(obj, "dict"):
+            return obj.dict()
+        return super().default(obj)
+
+
+def add_graph_node(node: GraphNode, time_service: TimeServiceProtocol, db_path: Optional[str] = None) -> str:
+    """Insert or update a graph node, merging attributes if it exists."""
+    logger.debug(
+        f"add_graph_node: node_id={node.id!r}, scope={node.scope.value!r}, type={node.type.value!r}, db_path={db_path!r}"
+    )
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            # First check if node exists and get its current attributes
+            cursor = conn.cursor()
+            logger.debug("DEBUG add_graph_node: Executing SELECT to check if node exists")
+            cursor.execute(
+                "SELECT attributes_json FROM graph_nodes WHERE node_id = ? AND scope = ?", (node.id, node.scope.value)
+            )
+            existing_row = cursor.fetchone()
+            logger.debug(f"DEBUG add_graph_node: existing_row = {existing_row}")
+
+            if existing_row:
+                # Node exists - merge attributes
+                existing_attrs = parse_json_field(existing_row["attributes_json"])
+
+                # Convert node.attributes to dict if it's a Pydantic model
+                if hasattr(node.attributes, "model_dump"):
+                    new_attrs = node.attributes.model_dump()
+                elif hasattr(node.attributes, "dict"):
+                    new_attrs = node.attributes.dict()
+                else:  # isinstance(node.attributes, dict)
+                    new_attrs = node.attributes
+
+                # Merge attributes - new values override old ones
+                merged_attrs = {**existing_attrs, **new_attrs}
+
+                # Update the node
+                sql = """
+                    UPDATE graph_nodes
+                    SET attributes_json = :attributes_json,
+                        version = version + 1,
+                        updated_by = :updated_by,
+                        updated_at = :updated_at
+                    WHERE node_id = :node_id AND scope = :scope
+                """
+                params = {
+                    "node_id": node.id,
+                    "scope": node.scope.value,
+                    "attributes_json": json.dumps(merged_attrs, cls=DateTimeEncoder),
+                    "updated_by": node.updated_by,
+                    "updated_at": node.updated_at or time_service.now().isoformat(),
+                }
+                logger.debug("Updating graph node %s with merged attributes", node.id)
+            else:
+                # Node doesn't exist - insert new
+                sql = """
+                    INSERT INTO graph_nodes
+                    (node_id, scope, node_type, attributes_json, version, updated_by, updated_at)
+                    VALUES (:node_id, :scope, :node_type, :attributes_json, :version, :updated_by, :updated_at)
+                """
+                params = {
+                    "node_id": node.id,
+                    "scope": node.scope.value,
+                    "node_type": node.type.value,
+                    "attributes_json": json.dumps(node.attributes, cls=DateTimeEncoder),
+                    "version": str(node.version),  # Convert to string for SQL params
+                    "updated_by": node.updated_by,
+                    "updated_at": node.updated_at or time_service.now().isoformat(),
+                }
+                logger.debug("Inserting new graph node %s", node.id)
+
+            logger.debug(f"add_graph_node: Executing {'UPDATE' if existing_row else 'INSERT'} with params: {params}")
+            cursor.execute(sql, params)
+            logger.debug(f"add_graph_node: cursor.rowcount = {cursor.rowcount}")
+            conn.commit()
+            logger.debug("add_graph_node: Committed successfully")
+
+            # If we just created a new USER node, ensure TEMPORARY consent exists
+            if not existing_row and node.type == NodeType.USER:
+                logger.info(f"New USER node created: {node.id}. Creating TEMPORARY consent.")
+                try:
+                    # Import here to avoid circular dependencies
+                    from ciris_engine.schemas.consent.core import ConsentStream
+
+                    # Store consent directly in database
+                    # NOTE: Cannot use ConsentService.grant_consent() here because:
+                    # 1. add_graph_node() is synchronous but grant_consent() is async
+                    # 2. This runs during node persistence, before services are fully initialized
+                    consent_node = GraphNode(
+                        id=f"consent_{node.id}",
+                        type=NodeType.CONSENT,
+                        scope=GraphScope.LOCAL,
+                        attributes={
+                            "user_id": node.id,
+                            "stream": ConsentStream.TEMPORARY.value,
+                            "granted_at": time_service.now().isoformat(),
+                            "expires_at": (
+                                time_service.now() + timedelta(days=14)
+                            ).isoformat(),  # 14-day temporary consent
+                            "reason": "Default TEMPORARY consent on user creation",
+                            "categories": [],
+                            "impact_score": 0.0,
+                            "attribution_count": 0,
+                        },
+                        updated_by="system_user_creation",
+                        updated_at=time_service.now(),
+                    )
+
+                    # Recursively add the consent node (but it won't trigger again since it's not a USER type)
+                    add_graph_node(consent_node, time_service=time_service, db_path=db_path)
+                    logger.info(f"Created TEMPORARY consent for new user {node.id}")
+
+                except Exception as e:
+                    logger.warning(f"Could not create consent for user {node.id}: {e}")
+                    # Don't fail the node creation if consent fails
+
+        logger.debug("Successfully saved graph node %s in scope %s", node.id, node.scope.value)
+        return node.id
+    except Exception as e:
+        logger.exception("Failed to add/update graph node %s: %s", node.id, e)
+        raise
+
+
+def get_graph_node(node_id: str, scope: GraphScope, db_path: Optional[str] = None) -> Optional[GraphNode]:
+    sql = "SELECT * FROM graph_nodes WHERE node_id = ? AND scope = ?"
+    logger.debug(f"get_graph_node: node_id={node_id!r}, scope={scope.value!r}, db_path={db_path!r}")
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            cursor = conn.cursor()
+            logger.debug("DEBUG get_graph_node: Executing SELECT")
+            cursor.execute(sql, (node_id, scope.value))
+            row = cursor.fetchone()
+            logger.debug(f"get_graph_node: row = {row}")
+            if row:
+                attrs = parse_json_field(row["attributes_json"])
+                return GraphNode(
+                    id=row["node_id"],
+                    type=row["node_type"],
+                    scope=scope,
+                    attributes=attrs,
+                    version=row["version"],
+                    updated_by=row["updated_by"],
+                    updated_at=row["updated_at"],
+                )
+            return None
+    except Exception as e:
+        logger.exception("Failed to fetch graph node %s: %s", node_id, e)
+        return None
+
+
+def delete_graph_node(node_id: str, scope: GraphScope, db_path: Optional[str] = None) -> int:
+    sql = "DELETE FROM graph_nodes WHERE node_id = ? AND scope = ?"
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            cursor = conn.execute(sql, (node_id, scope.value))
+            conn.commit()
+            return cursor.rowcount
+    except Exception as e:
+        logger.exception("Failed to delete graph node %s: %s", node_id, e)
+        return 0
+
+
+def add_graph_edge(edge: GraphEdge, db_path: Optional[str] = None) -> str:
+    adapter = get_adapter()
+    columns = ["edge_id", "source_node_id", "target_node_id", "scope", "relationship", "weight", "attributes_json"]
+    sql = adapter.upsert(table="graph_edges", columns=columns, conflict_columns=["edge_id"])
+
+    edge_id = f"{edge.source}->{edge.target}->{edge.relationship}"  # deterministic
+    params = {
+        "edge_id": edge_id,
+        "source_node_id": edge.source,
+        "target_node_id": edge.target,
+        "scope": edge.scope.value,
+        "relationship": edge.relationship,
+        "weight": edge.weight,
+        "attributes_json": json.dumps(edge.attributes, cls=DateTimeEncoder),
+    }
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            conn.execute(sql, params)
+            conn.commit()
+        logger.debug("Added graph edge %s", edge_id)
+        return edge_id
+    except Exception as e:
+        logger.exception("Failed to add graph edge %s: %s", edge_id, e)
+        raise
+
+
+def delete_graph_edge(edge_id: str, db_path: Optional[str] = None) -> int:
+    sql = "DELETE FROM graph_edges WHERE edge_id = ?"
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            cursor = conn.execute(sql, (edge_id,))
+            conn.commit()
+            return cursor.rowcount
+    except Exception as e:
+        logger.exception("Failed to delete graph edge %s: %s", edge_id, e)
+        return 0
+
+
+def get_edges_for_node(node_id: str, scope: GraphScope, db_path: Optional[str] = None) -> List[GraphEdge]:
+    sql = "SELECT * FROM graph_edges WHERE scope = ? AND (source_node_id = ? OR target_node_id = ?)"
+    edges: List[GraphEdge] = []
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            cursor = conn.cursor()
+            # Note: PostgreSQLCursorWrapper automatically translates ? to %s
+            cursor.execute(sql, (scope.value, node_id, node_id))
+            rows = cursor.fetchall()
+            for row in rows:
+                attrs = parse_json_field(row["attributes_json"])
+                # Extract only valid GraphEdgeAttributes fields
+                valid_attrs = {}
+                if "created_at" in attrs:
+                    valid_attrs["created_at"] = attrs["created_at"]
+                if "context" in attrs:
+                    valid_attrs["context"] = attrs["context"]
+
+                edges.append(
+                    GraphEdge(
+                        source=row["source_node_id"],
+                        target=row["target_node_id"],
+                        relationship=row["relationship"],
+                        scope=scope,
+                        weight=row["weight"],
+                        attributes=GraphEdgeAttributes(**valid_attrs) if valid_attrs else GraphEdgeAttributes(),
+                    )
+                )
+    except Exception as e:
+        logger.exception("Failed to fetch edges for node %s: %s", node_id, e)
+    return edges
+
+
+def get_all_graph_nodes(
+    scope: Optional[GraphScope] = None,
+    node_type: Optional[str] = None,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    db_path: Optional[str] = None,
+) -> List[GraphNode]:
+    """
+    Get all graph nodes with optional filters.
+
+    Args:
+        scope: Filter by scope (optional)
+        node_type: Filter by node type (optional)
+        limit: Maximum number of nodes to return
+        offset: Number of nodes to skip (for pagination)
+        db_path: Optional database path
+
+    Returns:
+        List of GraphNode objects
+    """
+    sql = "SELECT * FROM graph_nodes WHERE 1=1"
+    params: List[Any] = []
+
+    if scope is not None:
+        sql += " AND scope = ?"
+        params.append(scope.value if hasattr(scope, "value") else scope)
+
+    if node_type is not None:
+        sql += " AND node_type = ?"
+        params.append(node_type)
+
+    sql += " ORDER BY updated_at DESC"
+
+    if limit is not None:
+        sql += " LIMIT ?"
+        params.append(limit)
+
+    if offset is not None:
+        sql += " OFFSET ?"
+        params.append(offset)
+
+    nodes = []
+    try:
+        with get_db_connection(db_path=db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(sql, params)
+            rows = cursor.fetchall()
+
+            for row in rows:
+                attrs = parse_json_field(row["attributes_json"])
+                nodes.append(
+                    GraphNode(
+                        id=row["node_id"],
+                        type=row["node_type"],
+                        scope=row["scope"],
+                        attributes=attrs,
+                        version=row["version"],
+                        updated_by=row["updated_by"],
+                        updated_at=row["updated_at"],
+                    )
+                )
+
+        logger.debug("Retrieved %d graph nodes with filters scope=%s, type=%s", len(nodes), scope, node_type)
+        return nodes
+
+    except Exception as e:
+        logger.exception("Failed to fetch all graph nodes: %s", e)
+        return []
+
+
+def get_nodes_by_type(
+    node_type: str,
+    scope: Optional[GraphScope] = None,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    db_path: Optional[str] = None,
+) -> List[GraphNode]:
+    """
+    Get all nodes of a specific type.
+
+    Args:
+        node_type: The type of nodes to retrieve
+        scope: Filter by scope (optional)
+        limit: Maximum number of nodes to return
+        offset: Number of nodes to skip (for pagination)
+        db_path: Optional database path
+
+    Returns:
+        List of GraphNode objects of the specified type
+    """
+    return get_all_graph_nodes(scope=scope, node_type=node_type, limit=limit, offset=offset, db_path=db_path)

ciris_engine/logic/persistence/models/identity.py

@@ -0,0 +1,264 @@
+"""
+Identity persistence model for storing and retrieving agent identity from the graph database.
+
+This module provides robust functions for managing agent identity as the primary source
+of truth, replacing the legacy profile system.
+"""
+
+import json
+import logging
+from typing import Optional
+
+from ciris_engine.logic.persistence.db import get_db_connection
+from ciris_engine.logic.persistence.models.graph import add_graph_node, get_graph_node
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.persistence.core import IdentityContext
+from ciris_engine.schemas.runtime.core import AgentIdentityRoot
+from ciris_engine.schemas.runtime.extended import CreationCeremonyRequest
+from ciris_engine.schemas.services.graph_core import GraphNode, GraphScope, NodeType
+
+logger = logging.getLogger(__name__)
+
+
+def store_agent_identity(
+    identity: AgentIdentityRoot, time_service: TimeServiceProtocol, db_path: Optional[str] = None
+) -> bool:
+    """
+    Store agent identity in the graph database.
+
+    Args:
+        identity: The agent identity to store
+        db_path: Optional database path override
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Import IdentityNode
+        from ciris_engine.schemas.services.nodes import IdentityNode
+
+        # Convert AgentIdentityRoot to IdentityNode
+        identity_node = IdentityNode.from_agent_identity_root(identity, time_service)
+
+        # Convert to GraphNode for storage
+        graph_node = identity_node.to_graph_node()
+
+        # Store in graph
+        add_graph_node(graph_node, time_service, db_path=db_path)
+        logger.info(f"Stored identity for agent {identity.agent_id}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to store agent identity: {e}", exc_info=True)
+        return False
+
+
+def retrieve_agent_identity(db_path: Optional[str] = None) -> Optional[AgentIdentityRoot]:
+    """
+    Retrieve agent identity from the graph database.
+
+    Args:
+        db_path: Optional database path override
+
+    Returns:
+        AgentIdentityRoot if found, None otherwise
+    """
+    try:
+        # Import IdentityNode
+        from ciris_engine.schemas.services.nodes import IdentityNode
+
+        # Get identity node
+        graph_node = get_graph_node(node_id="agent/identity", scope=GraphScope.IDENTITY, db_path=db_path)
+
+        if not graph_node:
+            logger.debug("No identity node found in graph")
+            return None
+
+        # Convert GraphNode back to IdentityNode
+        identity_node = IdentityNode.from_graph_node(graph_node)
+
+        # Convert to AgentIdentityRoot
+        agent_identity = identity_node.to_agent_identity_root()
+
+        logger.info(f"Retrieved identity for agent {agent_identity.agent_id}")
+        return agent_identity
+
+    except Exception as e:
+        logger.error(f"Failed to retrieve agent identity: {e}", exc_info=True)
+        return None
+
+
+def update_agent_identity(
+    identity: AgentIdentityRoot, updated_by: str, time_service: TimeServiceProtocol, db_path: Optional[str] = None
+) -> bool:
+    """
+    Update agent identity in the graph database.
+
+    NOTE: This requires WA approval as it modifies IDENTITY scope nodes.
+    The approval check should be done BEFORE calling this function.
+
+    Args:
+        identity: The updated agent identity
+        updated_by: WA ID who approved the update
+        db_path: Optional database path override
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Get current node to preserve version
+        current_node = get_graph_node(node_id="agent/identity", scope=GraphScope.IDENTITY, db_path=db_path)
+
+        version = 1
+        if current_node:
+            version = current_node.version + 1
+
+        # Create updated node
+        # Create proper GraphNodeAttributes
+        from ciris_engine.schemas.services.graph_core import GraphNodeAttributes
+
+        attributes = GraphNodeAttributes(
+            created_at=time_service.now(),
+            updated_at=time_service.now(),
+            created_by=updated_by,
+            tags=[f"identity:{identity.agent_id}", f"version:{version}"],
+        )
+
+        identity_node = GraphNode(
+            id="agent/identity",
+            type=NodeType.AGENT,
+            scope=GraphScope.IDENTITY,
+            attributes=attributes,
+            version=version,
+            updated_by=updated_by,
+            updated_at=time_service.now(),
+        )
+
+        # Store updated identity
+        add_graph_node(identity_node, time_service, db_path=db_path)
+        logger.info(f"Updated identity for agent {identity.agent_id} by {updated_by}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to update agent identity: {e}", exc_info=True)
+        return False
+
+
+def store_creation_ceremony(
+    ceremony_request: CreationCeremonyRequest,
+    new_agent_id: str,
+    ceremony_id: str,
+    time_service: TimeServiceProtocol,
+    db_path: Optional[str] = None,
+) -> bool:
+    """
+    Store a creation ceremony record in the database.
+
+    Args:
+        ceremony_request: The creation ceremony request
+        new_agent_id: ID of the newly created agent
+        ceremony_id: Unique ceremony identifier
+        db_path: Optional database path override
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        sql = """
+            INSERT INTO creation_ceremonies (
+                ceremony_id, timestamp, creator_agent_id, creator_human_id,
+                wise_authority_id, new_agent_id, new_agent_name, new_agent_purpose,
+                new_agent_description, creation_justification, expected_capabilities,
+                ethical_considerations, template_profile_hash, ceremony_status
+            ) VALUES (
+                :ceremony_id, :timestamp, :creator_agent_id, :creator_human_id,
+                :wise_authority_id, :new_agent_id, :new_agent_name, :new_agent_purpose,
+                :new_agent_description, :creation_justification, :expected_capabilities,
+                :ethical_considerations, :template_profile_hash, :ceremony_status
+            )
+        """
+
+        params = {
+            "ceremony_id": ceremony_id,
+            "timestamp": time_service.now().isoformat(),
+            "creator_agent_id": "system",  # Or current agent ID if agent-initiated
+            "creator_human_id": ceremony_request.human_id,
+            "wise_authority_id": ceremony_request.wise_authority_id or ceremony_request.human_id,
+            "new_agent_id": new_agent_id,
+            "new_agent_name": ceremony_request.proposed_name,
+            "new_agent_purpose": ceremony_request.proposed_purpose,
+            "new_agent_description": ceremony_request.proposed_description,
+            "creation_justification": ceremony_request.creation_justification,
+            "expected_capabilities": json.dumps(ceremony_request.expected_capabilities),
+            "ethical_considerations": ceremony_request.ethical_considerations,
+            "template_profile_hash": hash(ceremony_request.template_profile),
+            "ceremony_status": "completed",
+        }
+
+        with get_db_connection(db_path=db_path) as conn:
+            conn.execute(sql, params)
+            conn.commit()
+
+        logger.info(f"Stored creation ceremony {ceremony_id} for agent {new_agent_id}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to store creation ceremony: {e}", exc_info=True)
+        return False
+
+
+def get_identity_for_context(db_path: Optional[str] = None) -> IdentityContext:
+    """
+    Get identity information formatted for use in processing contexts.
+
+    This is a synchronous version for use in contexts that can't await.
+
+    Returns:
+        IdentityContext with typed fields
+    """
+    try:
+        # Import IdentityNode
+        from ciris_engine.schemas.services.nodes import IdentityNode
+
+        graph_node = get_graph_node(node_id="agent/identity", scope=GraphScope.IDENTITY, db_path=db_path)
+
+        if not graph_node:
+            raise RuntimeError(
+                "CRITICAL: No agent identity found in graph database. System cannot start without identity."
+            )
+
+        # Convert GraphNode back to IdentityNode
+        identity_node = IdentityNode.from_graph_node(graph_node)
+
+        # Convert to AgentIdentityRoot
+        identity = identity_node.to_agent_identity_root()
+
+        # Convert permitted_actions strings to HandlerActionType enums
+        from ciris_engine.schemas.runtime.enums import HandlerActionType
+
+        permitted_action_enums = []
+        for action_str in identity.permitted_actions:
+            try:
+                # Try to convert action string to HandlerActionType
+                action = HandlerActionType(action_str.upper())
+                permitted_action_enums.append(action)
+            except ValueError:
+                # Skip actions that don't map to HandlerActionType
+                logger.debug(f"Action '{action_str}' does not map to a HandlerActionType")
+
+        return IdentityContext(
+            agent_name=identity.agent_id,
+            agent_role=identity.core_profile.role_description,
+            description=identity.core_profile.description,
+            domain_specific_knowledge=identity.core_profile.domain_specific_knowledge,
+            permitted_actions=permitted_action_enums,
+            restricted_capabilities=identity.restricted_capabilities,
+            # Include overrides for DMAs
+            dsdma_prompt_template=identity.core_profile.dsdma_prompt_template,
+            csdma_overrides=identity.core_profile.csdma_overrides,
+            action_selection_pdma_overrides=identity.core_profile.action_selection_pdma_overrides,
+        )
+
+    except Exception as e:
+        logger.critical(f"CRITICAL: Failed to retrieve agent identity: {e}", exc_info=True)
+        raise RuntimeError(f"Cannot operate without valid agent identity: {e}") from e