agno 2.0.4__py3-none-any.whl → 2.0.6__py3-none-any.whl

agno/db/json/json_db.py

@@ -17,9 +17,9 @@ from agno.db.json.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import generate_deterministic_id
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.string import generate_id
 
 
 class JsonDb(BaseDb):
@@ -47,7 +47,7 @@ class JsonDb(BaseDb):
         """
         if id is None:
             seed = db_path or "agno_json_db"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -168,7 +168,7 @@ class JsonDb(BaseDb):
     def get_session(
         self,
         session_id: str,
-        session_type: Optional[SessionType] = None,
+        session_type: SessionType,
         user_id: Optional[str] = None,
         deserialize: Optional[bool] = True,
     ) -> Optional[Union[AgentSession, TeamSession, WorkflowSession, Dict[str, Any]]]:
@@ -176,7 +176,7 @@ class JsonDb(BaseDb):
 
         Args:
             session_id (str): The ID of the session to read.
-            session_type (Optional[SessionType]): The type of the session to read.
+            session_type (SessionType): The type of the session to read.
             user_id (Optional[str]): The ID of the user to read the session for.
             deserialize (Optional[bool]): Whether to deserialize the session.
 
@@ -208,8 +208,10 @@ class JsonDb(BaseDb):
                         return AgentSession.from_dict(session)
                     elif session_type == SessionType.TEAM:
                         return TeamSession.from_dict(session)
-                    else:
+                    elif session_type == SessionType.WORKFLOW:
                         return WorkflowSession.from_dict(session)
+                    else:
+                        raise ValueError(f"Invalid session type: {session_type}")
 
             return None
 
@@ -338,8 +340,10 @@ class JsonDb(BaseDb):
                         return AgentSession.from_dict(session)
                     elif session_type == SessionType.TEAM:
                         return TeamSession.from_dict(session)
-                    else:
+                    elif session_type == SessionType.WORKFLOW:
                         return WorkflowSession.from_dict(session)
+                    else:
+                        raise ValueError(f"Invalid session type: {session_type}")
 
             return None
 

agno/db/migrations/v1_to_v2.py

@@ -1,9 +1,11 @@
 """Migration utility to migrate your Agno tables from v1 to v2"""
 
+import json
 from typing import Any, Dict, List, Optional, Union
 
 from sqlalchemy import text
 
+from agno.db.mongo.mongo import MongoDb
 from agno.db.mysql.mysql import MySQLDb
 from agno.db.postgres.postgres import PostgresDb
 from agno.db.schemas.memory import UserMemory
@@ -12,24 +14,171 @@ from agno.session import AgentSession, TeamSession, WorkflowSession
 from agno.utils.log import log_error
 
 
+def convert_v1_metrics_to_v2(metrics_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert v1 metrics dictionary to v2 format by mapping old field names to new ones."""
+    if not isinstance(metrics_dict, dict):
+        return metrics_dict
+
+    # Create a copy to avoid modifying the original
+    v2_metrics = metrics_dict.copy()
+
+    # Map v1 field names to v2 field names
+    field_mappings = {
+        "time": "duration",
+        "audio_tokens": "audio_total_tokens",
+        "input_audio_tokens": "audio_input_tokens",
+        "output_audio_tokens": "audio_output_tokens",
+        "cached_tokens": "cache_read_tokens",
+    }
+
+    # Fields to remove (deprecated in v2)
+    deprecated_fields = ["prompt_tokens", "completion_tokens", "prompt_tokens_details", "completion_tokens_details"]
+
+    # Apply field mappings
+    for old_field, new_field in field_mappings.items():
+        if old_field in v2_metrics:
+            v2_metrics[new_field] = v2_metrics.pop(old_field)
+
+    # Remove deprecated fields
+    for field in deprecated_fields:
+        v2_metrics.pop(field, None)
+
+    return v2_metrics
+
+
+def convert_any_metrics_in_data(data: Any) -> Any:
+    """Recursively find and convert any metrics dictionaries in the data structure."""
+    if isinstance(data, dict):
+        # First filter out deprecated v1 fields
+        data = filter_deprecated_v1_fields(data)
+
+        # Check if this looks like a metrics dictionary
+        if _is_metrics_dict(data):
+            return convert_v1_metrics_to_v2(data)
+
+        # Otherwise, recursively process all values
+        converted_dict = {}
+        for key, value in data.items():
+            # Special handling for 'metrics' keys - always convert their values
+            if key == "metrics" and isinstance(value, dict):
+                converted_dict[key] = convert_v1_metrics_to_v2(value)
+            else:
+                converted_dict[key] = convert_any_metrics_in_data(value)
+        return converted_dict
+
+    elif isinstance(data, list):
+        return [convert_any_metrics_in_data(item) for item in data]
+
+    else:
+        # Not a dict or list, return as-is
+        return data
+
+
+def _is_metrics_dict(data: Dict[str, Any]) -> bool:
+    """Check if a dictionary looks like a metrics dictionary based on common field names."""
+    if not isinstance(data, dict):
+        return False
+
+    # Common metrics field names (both v1 and v2)
+    metrics_indicators = {
+        "input_tokens",
+        "output_tokens",
+        "total_tokens",
+        "time",
+        "duration",
+        "audio_tokens",
+        "audio_total_tokens",
+        "audio_input_tokens",
+        "audio_output_tokens",
+        "cached_tokens",
+        "cache_read_tokens",
+        "cache_write_tokens",
+        "reasoning_tokens",
+        "prompt_tokens",
+        "completion_tokens",
+        "time_to_first_token",
+        "provider_metrics",
+        "additional_metrics",
+    }
+
+    # Deprecated v1 fields that are strong indicators this is a metrics dict
+    deprecated_v1_indicators = {"time", "audio_tokens", "cached_tokens", "prompt_tokens", "completion_tokens"}
+
+    # If we find any deprecated v1 field, it's definitely a metrics dict that needs conversion
+    if any(field in data for field in deprecated_v1_indicators):
+        return True
+
+    # Otherwise, if the dict has at least 2 metrics-related fields, consider it a metrics dict
+    matching_fields = sum(1 for field in data.keys() if field in metrics_indicators)
+    return matching_fields >= 2
+
+
+def convert_session_data_comprehensively(session_data: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """Comprehensively convert any metrics found anywhere in session_data from v1 to v2 format."""
+    if not session_data:
+        return session_data
+
+    # Use the recursive converter to find and fix all metrics
+    return convert_any_metrics_in_data(session_data)
+
+
+def safe_get_runs_from_memory(memory_data: Any) -> Any:
+    """Safely extract runs data from memory field, handling various data types."""
+    if memory_data is None:
+        return None
+
+    # If memory_data is a string, try to parse it as JSON
+    if isinstance(memory_data, str):
+        try:
+            memory_dict = json.loads(memory_data)
+            if isinstance(memory_dict, dict):
+                return memory_dict.get("runs")
+        except (json.JSONDecodeError, AttributeError):
+            # If JSON parsing fails, memory_data might just be a string value
+            return None
+
+    # If memory_data is already a dict, access runs directly
+    elif isinstance(memory_data, dict):
+        return memory_data.get("runs")
+
+    # For any other type, return None
+    return None
+
+
+def filter_deprecated_v1_fields(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Remove v1-only fields that don't exist in v2 models."""
+    if not isinstance(data, dict):
+        return data
+
+    # Fields that existed in v1 but were removed in v2
+    deprecated_fields = {
+        "team_session_id",  # RunOutput v1 field, removed in v2
+        "formatted_tool_calls",  # RunOutput v1 field, removed in v2
+        # Add other deprecated fields here as needed
+    }
+
+    # Create a copy and remove deprecated fields
+    filtered_data = {k: v for k, v in data.items() if k not in deprecated_fields}
+    return filtered_data
+
+
 def migrate(
-    db: Union[PostgresDb, MySQLDb, SqliteDb],
+    db: Union[PostgresDb, MySQLDb, SqliteDb, MongoDb],
     v1_db_schema: str,
     agent_sessions_table_name: Optional[str] = None,
     team_sessions_table_name: Optional[str] = None,
     workflow_sessions_table_name: Optional[str] = None,
     memories_table_name: Optional[str] = None,
 ):
-    """Given a PostgresDb and table names, parse and migrate the tables' content to the corresponding v2 tables.
+    """Given a database connection and table/collection names, parse and migrate the content to corresponding v2 tables/collections.
 
     Args:
-        db: The database to migrate
-        v1_db_schema: The schema of the v1 tables
-        agent_sessions_table_name: The name of the agent sessions table. If not provided, the agent sessions table will not be migrated.
-        team_sessions_table_name: The name of the team sessions table. If not provided, the team sessions table will not be migrated.
-        workflow_sessions_table_name: The name of the workflow sessions table. If not provided, the workflow sessions table will not be migrated.
-        workflow_v2_sessions_table_name: The name of the workflow v2 sessions table. If not provided, the workflow v2 sessions table will not be migrated.
-        memories_table_name: The name of the memories table. If not provided, the memories table will not be migrated.
+        db: The database to migrate (PostgresDb, MySQLDb, SqliteDb, or MongoDb)
+        v1_db_schema: The schema of the v1 tables (leave empty for SQLite and MongoDB)
+        agent_sessions_table_name: The name of the agent sessions table/collection. If not provided, agent sessions will not be migrated.
+        team_sessions_table_name: The name of the team sessions table/collection. If not provided, team sessions will not be migrated.
+        workflow_sessions_table_name: The name of the workflow sessions table/collection. If not provided, workflow sessions will not be migrated.
+        memories_table_name: The name of the memories table/collection. If not provided, memories will not be migrated.
     """
     if agent_sessions_table_name:
         db.migrate_table_from_v1_to_v2(
@@ -61,14 +210,33 @@ def migrate(
 
 
 def get_all_table_content(db, db_schema: str, table_name: str) -> list[dict[str, Any]]:
-    """Get all content from the given table"""
+    """Get all content from the given table/collection"""
     try:
-        with db.Session() as sess:
-            result = sess.execute(text(f"SELECT * FROM {db_schema}.{table_name}"))
-            return [row._asdict() for row in result]
+        # Check if this is a MongoDB instance
+        if hasattr(db, "database") and hasattr(db, "db_client"):
+            # MongoDB implementation
+            collection = db.database[table_name]
+            # Convert MongoDB documents to dictionaries and handle ObjectId
+            documents = list(collection.find({}))
+            # Convert ObjectId to string for compatibility
+            for doc in documents:
+                if "_id" in doc:
+                    doc["_id"] = str(doc["_id"])
+            return documents
+        else:
+            # SQL database implementation (PostgreSQL, MySQL, SQLite)
+            with db.Session() as sess:
+                # Handle empty schema by omitting the schema prefix (needed for SQLite)
+                if db_schema and db_schema.strip():
+                    sql_query = f"SELECT * FROM {db_schema}.{table_name}"
+                else:
+                    sql_query = f"SELECT * FROM {table_name}"
+
+                result = sess.execute(text(sql_query))
+                return [row._asdict() for row in result]
 
     except Exception as e:
-        log_error(f"Error getting all content from table {table_name}: {e}")
+        log_error(f"Error getting all content from table/collection {table_name}: {e}")
         return []
 
 
@@ -82,9 +250,9 @@ def parse_agent_sessions(v1_content: List[Dict[str, Any]]) -> List[AgentSession]
             "agent_data": item.get("agent_data"),
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
-            "session_data": item.get("session_data"),
-            "metadata": item.get("extra_data"),
-            "runs": item.get("memory", {}).get("runs"),
+            "session_data": convert_session_data_comprehensively(item.get("session_data")),
+            "metadata": convert_any_metrics_in_data(item.get("extra_data")),
+            "runs": convert_any_metrics_in_data(safe_get_runs_from_memory(item.get("memory"))),
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
         }
@@ -105,9 +273,9 @@ def parse_team_sessions(v1_content: List[Dict[str, Any]]) -> List[TeamSession]:
             "team_data": item.get("team_data"),
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
-            "session_data": item.get("session_data"),
-            "metadata": item.get("extra_data"),
-            "runs": item.get("memory", {}).get("runs"),
+            "session_data": convert_session_data_comprehensively(item.get("session_data")),
+            "metadata": convert_any_metrics_in_data(item.get("extra_data")),
+            "runs": convert_any_metrics_in_data(safe_get_runs_from_memory(item.get("memory"))),
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
         }
@@ -128,13 +296,13 @@ def parse_workflow_sessions(v1_content: List[Dict[str, Any]]) -> List[WorkflowSe
             "workflow_data": item.get("workflow_data"),
             "session_id": item.get("session_id"),
             "user_id": item.get("user_id"),
-            "session_data": item.get("session_data"),
-            "metadata": item.get("extra_data"),
+            "session_data": convert_session_data_comprehensively(item.get("session_data")),
+            "metadata": convert_any_metrics_in_data(item.get("extra_data")),
             "created_at": item.get("created_at"),
             "updated_at": item.get("updated_at"),
             # Workflow v2 specific fields
             "workflow_name": item.get("workflow_name"),
-            "runs": item.get("runs"),
+            "runs": convert_any_metrics_in_data(item.get("runs")),
         }
         workflow_session = WorkflowSession.from_dict(session)
         if workflow_session is not None:

agno/db/mongo/mongo.py

@@ -16,9 +16,10 @@ from agno.db.mongo.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import deserialize_session_json_fields, generate_deterministic_id, serialize_session_json_fields
+from agno.db.utils import deserialize_session_json_fields, serialize_session_json_fields
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.string import generate_id
 
 try:
     from pymongo import MongoClient, ReturnDocument
@@ -63,7 +64,7 @@ class MongoDb(BaseDb):
             base_seed = db_url or str(db_client)
             db_name_suffix = db_name if db_name is not None else "agno"
             seed = f"{base_seed}#{db_name_suffix}"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -252,8 +253,8 @@ class MongoDb(BaseDb):
 
         Args:
             session_id (str): The ID of the session to get.
+            session_type (SessionType): The type of session to get.
             user_id (Optional[str]): The ID of the user to get the session for.
-            session_type (Optional[SessionType]): The type of session to get.
             deserialize (Optional[bool]): Whether to serialize the session. Defaults to True.
 
         Returns:
@@ -284,12 +285,14 @@ class MongoDb(BaseDb):
             if not deserialize:
                 return session
 
-            if session_type == SessionType.AGENT.value:
+            if session_type == SessionType.AGENT:
                 return AgentSession.from_dict(session)
-            elif session_type == SessionType.TEAM.value:
+            elif session_type == SessionType.TEAM:
                 return TeamSession.from_dict(session)
-            else:
+            elif session_type == SessionType.WORKFLOW:
                 return WorkflowSession.from_dict(session)
+            else:
+                raise ValueError(f"Invalid session type: {session_type}")
 
         except Exception as e:
             log_error(f"Exception reading session: {e}")
@@ -1423,3 +1426,61 @@ class MongoDb(BaseDb):
         except Exception as e:
             log_error(f"Error updating eval run name {eval_run_id}: {e}")
             raise
+
+    def migrate_table_from_v1_to_v2(self, v1_db_schema: str, v1_table_name: str, v1_table_type: str):
+        """Migrate all content in the given collection to the right v2 collection"""
+
+        from typing import List, Sequence, Union
+
+        from agno.db.migrations.v1_to_v2 import (
+            get_all_table_content,
+            parse_agent_sessions,
+            parse_memories,
+            parse_team_sessions,
+            parse_workflow_sessions,
+        )
+
+        # Get all content from the old collection
+        old_content: list[dict[str, Any]] = get_all_table_content(
+            db=self,
+            db_schema=v1_db_schema,
+            table_name=v1_table_name,
+        )
+        if not old_content:
+            log_info(f"No content to migrate from collection {v1_table_name}")
+            return
+
+        # Parse the content into the new format
+        memories: List[UserMemory] = []
+        sessions: Sequence[Union[AgentSession, TeamSession, WorkflowSession]] = []
+        if v1_table_type == "agent_sessions":
+            sessions = parse_agent_sessions(old_content)
+        elif v1_table_type == "team_sessions":
+            sessions = parse_team_sessions(old_content)
+        elif v1_table_type == "workflow_sessions":
+            sessions = parse_workflow_sessions(old_content)
+        elif v1_table_type == "memories":
+            memories = parse_memories(old_content)
+        else:
+            raise ValueError(f"Invalid table type: {v1_table_type}")
+
+        # Insert the new content into the new collection
+        if v1_table_type == "agent_sessions":
+            for session in sessions:
+                self.upsert_session(session)
+            log_info(f"Migrated {len(sessions)} Agent sessions to collection: {self.session_table_name}")
+
+        elif v1_table_type == "team_sessions":
+            for session in sessions:
+                self.upsert_session(session)
+            log_info(f"Migrated {len(sessions)} Team sessions to collection: {self.session_table_name}")
+
+        elif v1_table_type == "workflow_sessions":
+            for session in sessions:
+                self.upsert_session(session)
+            log_info(f"Migrated {len(sessions)} Workflow sessions to collection: {self.session_table_name}")
+
+        elif v1_table_type == "memories":
+            for memory in memories:
+                self.upsert_user_memory(memory)
+            log_info(f"Migrated {len(memories)} memories to collection: {self.memory_table_name}")

agno/db/mysql/mysql.py

@@ -20,9 +20,9 @@ from agno.db.mysql.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import generate_deterministic_id
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.string import generate_id
 
 try:
     from sqlalchemy import TEXT, and_, cast, func, update
@@ -75,7 +75,7 @@ class MySQLDb(BaseDb):
             base_seed = db_url or str(db_engine.url)  # type: ignore
             schema_suffix = db_schema if db_schema is not None else "ai"
             seed = f"{base_seed}#{schema_suffix}"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -350,8 +350,8 @@ class MySQLDb(BaseDb):
 
         Args:
             session_id (str): ID of the session to read.
+            session_type (SessionType): Type of session to get.
             user_id (Optional[str]): User ID to filter by. Defaults to None.
-            session_type (Optional[SessionType]): Type of session to read. Defaults to None.
             deserialize (Optional[bool]): Whether to serialize the session. Defaults to True.
 
         Returns:
@@ -415,6 +415,7 @@ class MySQLDb(BaseDb):
         Get all sessions in the given table. Can filter by user_id and entity_id.
 
         Args:
+            session_type (Optional[SessionType]): The type of sessions to get.
             user_id (Optional[str]): The ID of the user to filter by.
             entity_id (Optional[str]): The ID of the agent / workflow to filter by.
             start_timestamp (Optional[int]): The start timestamp to filter by.
@@ -1711,17 +1712,17 @@ class MySQLDb(BaseDb):
         if v1_table_type == "agent_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "team_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "workflow_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "memories":
             for memory in memories:

agno/db/mysql/schemas.py

@@ -8,12 +8,12 @@ except ImportError:
     raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
 
 SESSION_TABLE_SCHEMA = {
-    "session_id": {"type": String, "nullable": False},
-    "session_type": {"type": String, "nullable": False, "index": True},
-    "agent_id": {"type": String, "nullable": True},
-    "team_id": {"type": String, "nullable": True},
-    "workflow_id": {"type": String, "nullable": True},
-    "user_id": {"type": String, "nullable": True},
+    "session_id": {"type": lambda: String(128), "nullable": False},
+    "session_type": {"type": lambda: String(20), "nullable": False, "index": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True},
+    "user_id": {"type": lambda: String(128), "nullable": True},
     "session_data": {"type": JSON, "nullable": True},
     "agent_data": {"type": JSON, "nullable": True},
     "team_data": {"type": JSON, "nullable": True},
@@ -32,50 +32,50 @@ SESSION_TABLE_SCHEMA = {
 }
 
 USER_MEMORY_TABLE_SCHEMA = {
-    "memory_id": {"type": String, "primary_key": True, "nullable": False},
+    "memory_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
     "memory": {"type": JSON, "nullable": False},
     "input": {"type": Text, "nullable": True},
-    "agent_id": {"type": String, "nullable": True},
-    "team_id": {"type": String, "nullable": True},
-    "user_id": {"type": String, "nullable": True, "index": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
     "topics": {"type": JSON, "nullable": True},
     "updated_at": {"type": BigInteger, "nullable": True, "index": True},
 }
 
 EVAL_TABLE_SCHEMA = {
-    "run_id": {"type": String, "primary_key": True, "nullable": False},
-    "eval_type": {"type": String, "nullable": False},
+    "run_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "eval_type": {"type": lambda: String(50), "nullable": False},
     "eval_data": {"type": JSON, "nullable": False},
     "eval_input": {"type": JSON, "nullable": False},
-    "name": {"type": String, "nullable": True},
-    "agent_id": {"type": String, "nullable": True},
-    "team_id": {"type": String, "nullable": True},
-    "workflow_id": {"type": String, "nullable": True},
-    "model_id": {"type": String, "nullable": True},
-    "model_provider": {"type": String, "nullable": True},
-    "evaluated_component_name": {"type": String, "nullable": True},
+    "name": {"type": lambda: String(255), "nullable": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True},
+    "model_id": {"type": lambda: String(128), "nullable": True},
+    "model_provider": {"type": lambda: String(128), "nullable": True},
+    "evaluated_component_name": {"type": lambda: String(255), "nullable": True},
     "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True},
 }
 
 KNOWLEDGE_TABLE_SCHEMA = {
-    "id": {"type": String, "primary_key": True, "nullable": False},
-    "name": {"type": String, "nullable": False},
+    "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "name": {"type": lambda: String(255), "nullable": False},
     "description": {"type": Text, "nullable": False},
     "metadata": {"type": JSON, "nullable": True},
-    "type": {"type": String, "nullable": True},
+    "type": {"type": lambda: String(50), "nullable": True},
     "size": {"type": BigInteger, "nullable": True},
-    "linked_to": {"type": String, "nullable": True},
+    "linked_to": {"type": lambda: String(128), "nullable": True},
     "access_count": {"type": BigInteger, "nullable": True},
     "created_at": {"type": BigInteger, "nullable": True},
     "updated_at": {"type": BigInteger, "nullable": True},
-    "status": {"type": String, "nullable": True},
+    "status": {"type": lambda: String(50), "nullable": True},
     "status_message": {"type": Text, "nullable": True},
-    "external_id": {"type": String, "nullable": True},
+    "external_id": {"type": lambda: String(128), "nullable": True},
 }
 
 METRICS_TABLE_SCHEMA = {
-    "id": {"type": String, "primary_key": True, "nullable": False},
+    "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
     "agent_runs_count": {"type": BigInteger, "nullable": False},
     "team_runs_count": {"type": BigInteger, "nullable": False},
     "workflow_runs_count": {"type": BigInteger, "nullable": False},
@@ -86,7 +86,7 @@ METRICS_TABLE_SCHEMA = {
     "token_metrics": {"type": JSON, "nullable": False},
     "model_metrics": {"type": JSON, "nullable": False},
     "date": {"type": Date, "nullable": False, "index": True},
-    "aggregation_period": {"type": String, "nullable": False},
+    "aggregation_period": {"type": lambda: String(20), "nullable": False},
     "created_at": {"type": BigInteger, "nullable": False},
     "updated_at": {"type": BigInteger, "nullable": True},
     "completed": {"type": Boolean, "nullable": False},

agno/db/postgres/postgres.py

@@ -18,9 +18,9 @@ from agno.db.postgres.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import generate_deterministic_id
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.string import generate_id
 
 try:
     from sqlalchemy import Index, String, UniqueConstraint, func, update
@@ -82,7 +82,7 @@ class PostgresDb(BaseDb):
             base_seed = db_url or str(db_engine.url)  # type: ignore
             schema_suffix = db_schema if db_schema is not None else "ai"
             seed = f"{base_seed}#{schema_suffix}"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -345,8 +345,8 @@ class PostgresDb(BaseDb):
 
         Args:
             session_id (str): ID of the session to read.
+            session_type (SessionType): Type of session to get.
             user_id (Optional[str]): User ID to filter by. Defaults to None.
-            session_type (Optional[SessionType]): Type of session to read. Defaults to None.
             deserialize (Optional[bool]): Whether to serialize the session. Defaults to True.
 
         Returns:
@@ -410,6 +410,7 @@ class PostgresDb(BaseDb):
         Get all sessions in the given table. Can filter by user_id and entity_id.
 
         Args:
+            session_type (Optional[SessionType]): The type of session to get.
             user_id (Optional[str]): The ID of the user to filter by.
             entity_id (Optional[str]): The ID of the agent / workflow to filter by.
             start_timestamp (Optional[int]): The start timestamp to filter by.
@@ -1700,17 +1701,17 @@ class PostgresDb(BaseDb):
         if v1_table_type == "agent_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "team_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "workflow_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "memories":
             for memory in memories: