acra-cli 0.1.1__py3-none-any.whl

acra/graph/workflow.py

@@ -0,0 +1,117 @@
+from langgraph.graph import (
+    StateGraph,
+    START,
+    END
+)
+import time
+
+from acra.graph.state import AgentState
+
+from acra.graph.nodes import (
+    NODE_REGISTRY
+)
+
+from acra.graph.conditional_edges import (
+    register_conditional_edges
+)
+
+from acra.graph.checkpoint import GraphCheckpointManager
+from acra.observability.metrics import metrics_tracker
+from acra.observability.monitoring import system_monitor
+
+
+class OmniAgentCallbacks:
+    """LangGraph callbacks for metrics and monitoring."""
+
+    raise_error = False
+    ignore_chain = False
+    ignore_agent = False
+    ignore_llm = False
+    ignore_chat_model = False
+
+    def on_chain_start(self, serialized, inputs, **kwargs):
+        try:
+            self._start = time.time()
+            agent = (serialized or {}).get("name", "unknown") if isinstance(serialized, dict) else "unknown"
+            system_monitor.info(agent, f"Agent started: {agent}")
+            metrics_tracker.record_agent_execution(agent)
+        except Exception:
+            return None
+
+    def on_chain_end(self, outputs, **kwargs):
+        try:
+            elapsed = time.time() - getattr(self, "_start", time.time())
+            system_monitor.info("workflow", f"Step completed in {elapsed:.2f}s")
+        except Exception:
+            return None
+
+    def on_chain_error(self, error, **kwargs):
+        try:
+            system_monitor.error("workflow", str(error))
+        except Exception:
+            return None
+
+    def on_chat_model_start(self, serialized, messages, **kwargs):
+        return None
+
+    def on_llm_end(self, response, **kwargs):
+        return None
+
+    def on_llm_error(self, error, **kwargs):
+        return None
+
+
+# Initialize checkpoint manager
+graph_checkpoint = GraphCheckpointManager()
+
+
+# create workflow graph
+
+def create_workflow():
+    """
+    Build OMNIAGENT workflow graph.
+    """
+
+    workflow = StateGraph(
+        AgentState
+    )
+
+    # register nodes
+
+    for (
+        node_name,
+        node_function
+    ) in NODE_REGISTRY.items():
+
+        workflow.add_node(
+            node_name,
+            node_function
+        )
+
+    # entry point
+
+    workflow.add_edge(
+        START,
+        "planner"
+    )
+
+    # conditional routing 
+
+    workflow = (
+        register_conditional_edges(
+            workflow
+        )
+    )
+
+    # compile graph with checkpointer
+
+    graph = workflow.compile(
+        checkpointer=graph_checkpoint.checkpointer
+    )
+
+    return graph
+
+
+# singleton workflow instance
+
+omniagent_graph = create_workflow()

acra/memory/__init__.py

@@ -0,0 +1 @@
+# Package acra/memory

acra/memory/checkpoints/__init__.py

@@ -0,0 +1 @@
+# Package acra/memory/checkpoints

acra/memory/checkpoints/data/__init__.py

@@ -0,0 +1 @@
+# Package acra/memory/checkpoints/data

acra/memory/checkpoints/postgres_checkpoint.py

@@ -0,0 +1,247 @@
+import json
+import os
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+import psycopg2
+from psycopg2.extras import RealDictCursor
+
+
+# postgres config 
+
+POSTGRES_HOST = os.getenv(
+    "POSTGRES_HOST",
+    "localhost"
+)
+
+POSTGRES_PORT = os.getenv(
+    "POSTGRES_PORT",
+    "5432"
+)
+
+POSTGRES_DB = os.getenv(
+    "POSTGRES_DB",
+    "omniagent"
+)
+
+POSTGRES_USER = os.getenv(
+    "POSTGRES_USER",
+    "postgres"
+)
+
+POSTGRES_PASSWORD = os.getenv(
+    "POSTGRES_PASSWORD",
+    "postgres"
+)
+
+
+# postgres checkpoint manager
+
+class PostgresCheckpointManager:
+    """
+    PostgreSQL workflow checkpoint system.
+
+    Responsibilities:
+    - scalable workflow persistence
+    - distributed checkpoint storage
+    - production-grade recovery
+    """
+
+    def __init__(self):
+        self.connection = None
+
+
+    # create connection
+
+    def _create_connection(self):
+
+        return psycopg2.connect(
+
+            host=POSTGRES_HOST,
+
+            port=POSTGRES_PORT,
+
+            dbname=POSTGRES_DB,
+
+            user=POSTGRES_USER,
+
+            password=POSTGRES_PASSWORD
+        )
+
+
+    # initialize Db
+
+    def _ensure_connection(self):
+        if self.connection is None:
+            self.connection = self._create_connection()
+            self._initialize_database()
+
+        return self.connection
+
+
+    def _initialize_database(self) -> None:
+        """
+        Create checkpoint table.
+        """
+
+        cursor = self.connection.cursor()
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS checkpoints (
+
+                id SERIAL PRIMARY KEY,
+
+                checkpoint_id TEXT UNIQUE,
+
+                session_id TEXT,
+
+                workflow_status TEXT,
+
+                active_agent TEXT,
+
+                retry_count INTEGER,
+
+                state_data JSONB,
+
+                created_at TIMESTAMP
+            )
+            """
+        )
+
+        self.connection.commit()
+
+        cursor.close()
+
+
+    # save checkpoint
+
+    def save_checkpoint(
+        self,
+        checkpoint_id: str,
+        session_id: str,
+        workflow_status: str,
+        active_agent: str,
+        retry_count: int,
+        state_data: Dict[str, Any]
+    ) -> Dict:
+        """
+        Persist workflow checkpoint.
+        """
+
+        try:
+
+            connection = self._ensure_connection()
+            cursor = connection.cursor()
+
+            cursor.execute(
+                """
+                INSERT INTO checkpoints (
+
+                    checkpoint_id,
+                    session_id,
+                    workflow_status,
+                    active_agent,
+                    retry_count,
+                    state_data,
+                    created_at
+
+                ) VALUES (%s, %s, %s, %s, %s, %s, %s)
+
+                ON CONFLICT (checkpoint_id)
+
+                DO UPDATE SET
+
+                    workflow_status = EXCLUDED.workflow_status,
+                    active_agent = EXCLUDED.active_agent,
+                    retry_count = EXCLUDED.retry_count,
+                    state_data = EXCLUDED.state_data
+                """,
+                (
+                    checkpoint_id,
+                    session_id,
+                    workflow_status,
+                    active_agent,
+                    retry_count,
+                    json.dumps(state_data),
+                    datetime.utcnow()
+                )
+            )
+
+            self.connection.commit()
+
+            cursor.close()
+
+            return {
+
+                "success": True,
+
+                "checkpoint_id": checkpoint_id
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+    # load checkpoint
+
+    def load_checkpoint(
+        self,
+        checkpoint_id: str
+    ) -> Dict:
+        """
+        Retrieve workflow checkpoint.
+        """
+
+        try:
+
+            connection = self._ensure_connection()
+            cursor = connection.cursor(
+                cursor_factory=RealDictCursor
+            )
+
+            cursor.execute(
+                """
+                SELECT *
+                FROM checkpoints
+                WHERE checkpoint_id = %s
+                """,
+                (checkpoint_id,)
+            )
+
+            result = cursor.fetchone()
+
+            cursor.close()
+
+            if not result:
+
+                return {
+
+                    "success": False,
+
+                    "error": (
+                        "Checkpoint not found."
+                    )
+                }
+
+            return {
+
+                "success": True,
+
+                "checkpoint": dict(result)
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }

acra/memory/checkpoints/sqlite_checkpoint.py

@@ -0,0 +1,309 @@
+import json
+import os
+import sqlite3
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from acra.config import SQLITE_DB_PATH
+
+
+# sqlite checkpoint manager
+
+class SQLiteCheckpointManager:
+    """
+    SQLite-based workflow checkpoint system.
+
+    Responsibilities:
+    - persist workflow state
+    - enable workflow recovery
+    - support resumable execution
+    - track autonomous execution history
+    """
+
+    def __init__(
+        self,
+        db_path: str = None
+    ):
+
+        if db_path is None:
+            db_path = str(SQLITE_DB_PATH)
+        self.db_path = db_path
+
+        self._initialize_database()
+
+
+    # initialize DB
+
+    def _initialize_database(self) -> None:
+        """
+        Create checkpoint table if missing.
+        """
+
+        connection = sqlite3.connect(
+            self.db_path
+        )
+
+        cursor = connection.cursor()
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS checkpoints (
+
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+
+                checkpoint_id TEXT UNIQUE,
+
+                session_id TEXT,
+
+                workflow_status TEXT,
+
+                active_agent TEXT,
+
+                retry_count INTEGER,
+
+                state_data TEXT,
+
+                created_at TEXT
+            )
+            """
+        )
+
+        connection.commit()
+
+        connection.close()
+
+
+    # save checkpoint
+
+    def save_checkpoint(
+        self,
+        checkpoint_id: str,
+        session_id: str,
+        workflow_status: str,
+        active_agent: str,
+        retry_count: int,
+        state_data: Dict[str, Any]
+    ) -> Dict:
+        """
+        Persist workflow checkpoint.
+        """
+
+        try:
+
+            connection = sqlite3.connect(
+                self.db_path
+            )
+
+            cursor = connection.cursor()
+
+            cursor.execute(
+                """
+                INSERT OR REPLACE INTO checkpoints (
+
+                    checkpoint_id,
+                    session_id,
+                    workflow_status,
+                    active_agent,
+                    retry_count,
+                    state_data,
+                    created_at
+
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    checkpoint_id,
+                    session_id,
+                    workflow_status,
+                    active_agent,
+                    retry_count,
+                    json.dumps(state_data),
+                    datetime.utcnow().isoformat()
+                )
+            )
+
+            connection.commit()
+
+            connection.close()
+
+            return {
+
+                "success": True,
+
+                "checkpoint_id": checkpoint_id
+            }
+
+        except Exception as e:
+            logging.getLogger(__name__).error("SQLiteCheckpointManager.save_checkpoint failed: %s", e, exc_info=True)
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+    # load checkpoint
+
+    def load_checkpoint(
+        self,
+        checkpoint_id: str
+    ) -> Dict:
+        """
+        Retrieve checkpoint by ID.
+        """
+
+        try:
+
+            connection = sqlite3.connect(
+                self.db_path
+            )
+
+            cursor = connection.cursor()
+
+            cursor.execute(
+                """
+                SELECT *
+                FROM checkpoints
+                WHERE checkpoint_id = ?
+                """,
+                (checkpoint_id,)
+            )
+
+            row = cursor.fetchone()
+
+            connection.close()
+
+            if not row:
+
+                return {
+
+                    "success": False,
+
+                    "error": (
+                        "Checkpoint not found."
+                    )
+                }
+
+            return {
+
+                "success": True,
+
+                "checkpoint": {
+
+                    "checkpoint_id": row[1],
+
+                    "session_id": row[2],
+
+                    "workflow_status": row[3],
+
+                    "active_agent": row[4],
+
+                    "retry_count": row[5],
+
+                    "state_data": json.loads(
+                        row[6]
+                    ),
+
+                    "created_at": row[7]
+                }
+            }
+
+        except Exception as e:
+            logging.getLogger(__name__).error("SQLiteCheckpointManager.load_checkpoint failed: %s", e, exc_info=True)
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+    # list checkpoints
+
+    def list_checkpoints(
+        self,
+        session_id: Optional[str] = None
+    ) -> Dict:
+        """
+        Retrieve stored checkpoints.
+        """
+
+        try:
+
+            connection = sqlite3.connect(
+                self.db_path
+            )
+
+            cursor = connection.cursor()
+
+            if session_id:
+
+                cursor.execute(
+                    """
+                    SELECT checkpoint_id,
+                           workflow_status,
+                           active_agent,
+                           created_at
+                    FROM checkpoints
+                    WHERE session_id = ?
+                    ORDER BY created_at DESC
+                    """,
+                    (session_id,)
+                )
+
+            else:
+
+                cursor.execute(
+                    """
+                    SELECT checkpoint_id,
+                           workflow_status,
+                           active_agent,
+                           created_at
+                    FROM checkpoints
+                    ORDER BY created_at DESC
+                    """
+                )
+
+            rows = cursor.fetchall()
+
+            connection.close()
+
+            checkpoints = []
+
+            for row in rows:
+
+                checkpoints.append({
+
+                    "checkpoint_id": row[0],
+
+                    "workflow_status": row[1],
+
+                    "active_agent": row[2],
+
+                    "created_at": row[3]
+                })
+
+            return {
+
+                "success": True,
+
+                "checkpoints": checkpoints
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+# global checkpoint manager 
+
+sqlite_checkpoint_manager = (
+    SQLiteCheckpointManager()
+)

acra/memory/chroma_db/__init__.py

@@ -0,0 +1 @@
+# Package acra/memory/chroma_db

acra/memory/conversation_memory/__init__.py

@@ -0,0 +1 @@
+# Package acra/memory/conversation_memory