agno 2.3.25__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/db/postgres/schemas.py

@@ -4,7 +4,7 @@ from typing import Any
 
 try:
     from sqlalchemy.dialects.postgresql import JSONB
-    from sqlalchemy.types import BigInteger, Boolean, Date, String, Text
+    from sqlalchemy.types import BigInteger, Boolean, Date, Integer, String, Text
 except ImportError:
     raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
 
@@ -169,6 +169,50 @@ def _get_span_table_schema(traces_table_name: str = "agno_traces", db_schema: st
     }
 
 
+COMPONENT_TABLE_SCHEMA = {
+    "component_id": {"type": String, "primary_key": True},
+    "component_type": {"type": String, "nullable": False, "index": True},  # agent|team|workflow
+    "name": {"type": String, "nullable": True, "index": True},
+    "description": {"type": Text, "nullable": True},
+    "current_version": {"type": Integer, "nullable": True, "index": True},
+    "metadata": {"type": JSONB, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "deleted_at": {"type": BigInteger, "nullable": True},
+}
+
+COMPONENT_CONFIGS_TABLE_SCHEMA = {
+    "component_id": {"type": String, "primary_key": True, "foreign_key": "components.component_id"},
+    "version": {"type": Integer, "primary_key": True},
+    "label": {"type": String, "nullable": True},  # stable|v1.2.0|pre-refactor
+    "stage": {"type": String, "nullable": False, "default": "draft", "index": True},  # draft|published
+    "config": {"type": JSONB, "nullable": False},
+    "notes": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "deleted_at": {"type": BigInteger, "nullable": True},
+}
+
+COMPONENT_LINKS_TABLE_SCHEMA = {
+    "parent_component_id": {"type": String, "nullable": False},
+    "parent_version": {"type": Integer, "nullable": False},
+    "link_kind": {"type": String, "nullable": False, "index": True},
+    "link_key": {"type": String, "nullable": False},
+    "child_component_id": {"type": String, "nullable": False, "foreign_key": "components.component_id"},
+    "child_version": {"type": Integer, "nullable": True},
+    "position": {"type": Integer, "nullable": False},
+    "meta": {"type": JSONB, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": True, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "__primary_key__": ["parent_component_id", "parent_version", "link_kind", "link_key"],
+    "__foreign_keys__": [
+        {
+            "columns": ["parent_component_id", "parent_version"],
+            "ref_table": "component_configs",
+            "ref_columns": ["component_id", "version"],
+        }
+    ],
+}
 LEARNINGS_TABLE_SCHEMA = {
     "learning_id": {"type": String, "primary_key": True, "nullable": False},
     "learning_type": {"type": String, "nullable": False, "index": True},
@@ -214,6 +258,9 @@ def get_table_schema_definition(
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
         "versions": VERSIONS_TABLE_SCHEMA,
         "traces": TRACE_TABLE_SCHEMA,
+        "components": COMPONENT_TABLE_SCHEMA,
+        "component_configs": COMPONENT_CONFIGS_TABLE_SCHEMA,
+        "component_links": COMPONENT_LINKS_TABLE_SCHEMA,
         "learnings": LEARNINGS_TABLE_SCHEMA,
     }
 

agno/db/sqlite/async_sqlite.py

@@ -7,7 +7,7 @@ from uuid import uuid4
 if TYPE_CHECKING:
     from agno.tracing.schemas import Span, Trace
 
-from agno.db.base import AsyncBaseDb, SessionType
+from agno.db.base import AsyncBaseDb, ComponentType, SessionType
 from agno.db.migrations.manager import MigrationManager
 from agno.db.schemas.culture import CulturalKnowledge
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
@@ -362,7 +362,7 @@ class AsyncSqliteDb(AsyncBaseDb):
         table_name: str,
         table_type: str,
         create_table_if_not_found: Optional[bool] = False,
-    ) -> Table:
+    ) -> Optional[Table]:
         """
         Check if the table exists and is valid, else create it.
 
@@ -376,7 +376,9 @@ class AsyncSqliteDb(AsyncBaseDb):
         async with self.async_session_factory() as sess, sess.begin():
             table_is_available = await ais_table_available(session=sess, table_name=table_name)
 
-        if (not table_is_available) and create_table_if_not_found:
+        if not table_is_available:
+            if not create_table_if_not_found:
+                return None
             return await self._create_table(table_name=table_name, table_type=table_type)
 
         # SQLite version of table validation (no schema)
@@ -3090,7 +3092,7 @@ class AsyncSqliteDb(AsyncBaseDb):
             async with self.async_session_factory() as sess, sess.begin():
                 stmt = table.delete().where(table.c.learning_id == id)
                 result = await sess.execute(stmt)
-                return result.rowcount > 0
+                return getattr(result, "rowcount", 0) > 0
 
         except Exception as e:
             log_debug(f"Error deleting learning: {e}")
@@ -3165,3 +3167,116 @@ class AsyncSqliteDb(AsyncBaseDb):
         except Exception as e:
             log_debug(f"Error getting learnings: {e}")
             return []
+
+    # --- Components (Not yet supported for async) ---
+    def get_component(
+        self,
+        component_id: str,
+        component_type: Optional[ComponentType] = None,
+    ) -> Optional[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def upsert_component(
+        self,
+        component_id: str,
+        component_type: Optional[ComponentType] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def delete_component(
+        self,
+        component_id: str,
+        hard_delete: bool = False,
+    ) -> bool:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def list_components(
+        self,
+        component_type: Optional[ComponentType] = None,
+        include_deleted: bool = False,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def create_component_with_config(
+        self,
+        component_id: str,
+        component_type: ComponentType,
+        name: Optional[str],
+        config: Dict[str, Any],
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        label: Optional[str] = None,
+        stage: str = "draft",
+        notes: Optional[str] = None,
+        links: Optional[List[Dict[str, Any]]] = None,
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def get_config(
+        self,
+        component_id: str,
+        version: Optional[int] = None,
+        label: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def upsert_config(
+        self,
+        component_id: str,
+        config: Optional[Dict[str, Any]] = None,
+        version: Optional[int] = None,
+        label: Optional[str] = None,
+        stage: Optional[str] = None,
+        notes: Optional[str] = None,
+        links: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def delete_config(
+        self,
+        component_id: str,
+        version: int,
+    ) -> bool:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def list_configs(
+        self,
+        component_id: str,
+        include_config: bool = False,
+    ) -> List[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def set_current_version(
+        self,
+        component_id: str,
+        version: int,
+    ) -> bool:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def get_links(
+        self,
+        component_id: str,
+        version: int,
+        link_kind: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def get_dependents(
+        self,
+        component_id: str,
+        version: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")
+
+    def load_component_graph(
+        self,
+        component_id: str,
+        version: Optional[int] = None,
+        label: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        raise NotImplementedError("Component methods not yet supported for async databases")

agno/db/sqlite/schemas.py

@@ -162,6 +162,54 @@ VERSIONS_TABLE_SCHEMA = {
     "updated_at": {"type": String, "nullable": True},
 }
 
+COMPONENTS_TABLE_SCHEMA = {
+    "component_id": {"type": String, "primary_key": True},
+    "component_type": {"type": String, "nullable": False, "index": True},  # agent|team|workflow
+    "name": {"type": String, "nullable": False, "index": True},
+    "description": {"type": String, "nullable": True},
+    "current_version": {"type": BigInteger, "nullable": True, "index": True},
+    "metadata": {"type": JSON, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "deleted_at": {"type": BigInteger, "nullable": True},
+}
+
+COMPONENT_CONFIGS_TABLE_SCHEMA = {
+    "component_id": {"type": String, "nullable": False},
+    "version": {"type": BigInteger, "nullable": False},
+    "label": {"type": String, "nullable": True},  # stable|v1.2.0|pre-refactor
+    "stage": {"type": String, "nullable": False, "default": "draft", "index": True},  # draft|published
+    "config": {"type": JSON, "nullable": False},
+    "notes": {"type": String, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "_unique_constraints": [
+        {
+            "name": "uq_config_component_version",
+            "columns": ["component_id", "version"],
+        },
+    ],
+}
+
+COMPONENT_LINKS_TABLE_SCHEMA = {
+    "parent_component_id": {"type": String, "nullable": False},
+    "parent_version": {"type": BigInteger, "nullable": False},
+    "link_kind": {"type": String, "nullable": False, "index": True},
+    "link_key": {"type": String, "nullable": False},
+    "child_component_id": {"type": String, "nullable": False},
+    "child_version": {"type": BigInteger, "nullable": True},
+    "position": {"type": BigInteger, "nullable": False},
+    "meta": {"type": JSON, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": True, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "_unique_constraints": [
+        {
+            "name": "uq_link_parent_kind_key",
+            "columns": ["parent_component_id", "parent_version", "link_kind", "link_key"],
+        },
+    ],
+}
+
 LEARNINGS_TABLE_SCHEMA = {
     "learning_id": {"type": String, "primary_key": True, "nullable": False},
     "learning_type": {"type": String, "nullable": False, "index": True},
@@ -204,6 +252,9 @@ def get_table_schema_definition(table_type: str, traces_table_name: str = "agno_
         "traces": TRACE_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
         "versions": VERSIONS_TABLE_SCHEMA,
+        "components": COMPONENTS_TABLE_SCHEMA,
+        "component_configs": COMPONENT_CONFIGS_TABLE_SCHEMA,
+        "component_links": COMPONENT_LINKS_TABLE_SCHEMA,
         "learnings": LEARNINGS_TABLE_SCHEMA,
     }
     schema = schemas.get(table_type, {})