letta-nightly 0.5.4.dev20241121104201__py3-none-any.whl → 0.5.4.dev20241123104112__py3-none-any.whl

letta/functions/helpers.py

@@ -13,8 +13,6 @@ def generate_composio_tool_wrapper(action: "ActionType") -> tuple[str, str]:
 
     wrapper_function_str = f"""
 def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
     from composio import Action, App, Tag
     from composio_langchain import ComposioToolSet
 
@@ -46,38 +44,6 @@ def generate_langchain_tool_wrapper(
     # Combine all parts into the wrapper function
     wrapper_function_str = f"""
 def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    import importlib
-    {import_statement}
-    {extra_module_imports}
-    {tool_instantiation}
-    {run_call}
-"""
-
-    # Compile safety check
-    assert_code_gen_compilable(wrapper_function_str)
-
-    return func_name, wrapper_function_str
-
-
-def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> tuple[str, str]:
-    tool_name = tool.__class__.__name__
-    import_statement = f"from crewai_tools import {tool_name}"
-    extra_module_imports = generate_import_code(additional_imports_module_attr_map)
-
-    # Safety check that user has passed in all required imports:
-    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
-
-    tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = humps.decamelize(tool_name)
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
     import importlib
     {import_statement}
     {extra_module_imports}
@@ -98,9 +64,7 @@ def assert_code_gen_compilable(code_str):
         print(f"Syntax error in code: {e}")
 
 
-def assert_all_classes_are_imported(
-    tool: Union["LangChainBaseTool", "CrewAIBaseTool"], additional_imports_module_attr_map: dict[str, str]
-) -> None:
+def assert_all_classes_are_imported(tool: Union["LangChainBaseTool"], additional_imports_module_attr_map: dict[str, str]) -> None:
     # Safety check that user has passed in all required imports:
     tool_name = tool.__class__.__name__
     current_class_imports = {tool_name}
@@ -114,7 +78,7 @@ def assert_all_classes_are_imported(
         raise RuntimeError(err_msg)
 
 
-def find_required_class_names_for_import(obj: Union["LangChainBaseTool", "CrewAIBaseTool", BaseModel]) -> list[str]:
+def find_required_class_names_for_import(obj: Union["LangChainBaseTool", BaseModel]) -> list[str]:
     """
     Finds all the class names for required imports when instantiating the `obj`.
     NOTE: This does not return the full import path, only the class name.
@@ -202,10 +166,10 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
     else:
         # Otherwise, if it is none of the above, that usually means it is a custom Python class that is NOT a BaseModel
         # Thus, we cannot get enough information about it to stringify it
-        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain or CrewAI
+        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain
         # An example would be that WikipediaAPIWrapper has an argument that is a wikipedia (pip install wikipedia) object
         # We cannot stringify this easily, but WikipediaAPIWrapper handles the setting of this parameter internally
-        # This assumption seems fair to me, since usually they are external imports, and LangChain and CrewAI should be bundling those as module-level imports within the tool
+        # This assumption seems fair to me, since usually they are external imports, and LangChain should be bundling those as module-level imports within the tool
         # We throw a warning here anyway and provide the class name
         print(
             f"[WARNING] Skipping parsing unknown class {obj.__class__.__name__} (does not inherit from the Pydantic BaseModel and is not a basic Python type)"
@@ -219,10 +183,9 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
 
 
 def is_base_model(obj: Any):
-    from crewai_tools.tools.base_tool import BaseModel as CrewAiBaseModel
     from langchain_core.pydantic_v1 import BaseModel as LangChainBaseModel
 
-    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel) or isinstance(obj, CrewAiBaseModel)
+    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel)
 
 
 def generate_import_code(module_attr_map: Optional[dict]):

letta/functions/schema_generator.py

@@ -1,5 +1,5 @@
 import inspect
-from typing import Any, Dict, Optional, Type, Union, get_args, get_origin
+from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
 from pydantic import BaseModel
@@ -38,15 +38,29 @@ def type_to_json_schema_type(py_type):
 
     # Mapping of Python types to JSON schema types
     type_map = {
+        # Basic types
         int: "integer",
         str: "string",
         bool: "boolean",
         float: "number",
-        list[str]: "array",
-        # Add more mappings as needed
+        # Collections
+        List[str]: "array",
+        List[int]: "array",
+        list: "array",
+        tuple: "array",
+        set: "array",
+        # Dictionaries
+        dict: "object",
+        Dict[str, Any]: "object",
+        # Special types
+        None: "null",
+        type(None): "null",
+        # Optional types
+        # Optional[str]: "string",  # NOTE: caught above ^
+        Union[str, None]: "string",
     }
     if py_type not in type_map:
-        raise ValueError(f"Python type {py_type} has no corresponding JSON schema type")
+        raise ValueError(f"Python type {py_type} has no corresponding JSON schema type - full map: {type_map}")
 
     return type_map.get(py_type, "string")  # Default to "string" if type not in map
 
@@ -93,9 +107,14 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
 
     for param in sig.parameters.values():
         # Exclude 'self' parameter
+        # TODO: eventually remove this (only applies to BASE_TOOLS)
         if param.name == "self":
             continue
 
+        # exclude 'agent_state' parameter
+        if param.name == "agent_state":
+            continue
+
         # Assert that the parameter has a type annotation
         if param.annotation == inspect.Parameter.empty:
             raise TypeError(f"Parameter '{param.name}' in function '{function.__name__}' lacks a type annotation")
@@ -129,6 +148,7 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
 
     # append the heartbeat
     # TODO: don't hard-code
+    # TODO: if terminal, don't include this
     if function.__name__ not in ["send_message", "pause_heartbeats"]:
         schema["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",

letta/local_llm/utils.py

@@ -88,16 +88,19 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
     try:
         encoding = tiktoken.encoding_for_model(model)
     except KeyError:
-        print("Warning: model not found. Using cl100k_base encoding.")
+        warnings.warn("Warning: model not found. Using cl100k_base encoding.")
         encoding = tiktoken.get_encoding("cl100k_base")
 
     num_tokens = 0
     for function in functions:
         function_tokens = len(encoding.encode(function["name"]))
         if function["description"]:
-            function_tokens += len(encoding.encode(function["description"]))
+            if not isinstance(function["description"], str):
+                warnings.warn(f"Function {function['name']} has non-string description: {function['description']}")
+            else:
+                function_tokens += len(encoding.encode(function["description"]))
         else:
-            raise ValueError(f"Function {function['name']} has no description, function: {function}")
+            warnings.warn(f"Function {function['name']} has no description, function: {function}")
 
         if "parameters" in function:
             parameters = function["parameters"]

letta/log.py

@@ -23,12 +23,10 @@ def _setup_logfile() -> "Path":
 # TODO: production logging should be much less invasive
 DEVELOPMENT_LOGGING = {
     "version": 1,
-    "disable_existing_loggers": True,
+    "disable_existing_loggers": False,  # Allow capturing from all loggers
     "formatters": {
         "standard": {"format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"},
-        "no_datetime": {
-            "format": "%(name)s - %(levelname)s - %(message)s",
-        },
+        "no_datetime": {"format": "%(name)s - %(levelname)s - %(message)s"},
     },
     "handlers": {
         "console": {
@@ -46,14 +44,14 @@ DEVELOPMENT_LOGGING = {
             "formatter": "standard",
         },
     },
+    "root": {  # Root logger handles all logs
+        "level": logging.DEBUG if settings.debug else logging.INFO,
+        "handlers": ["console", "file"],
+    },
     "loggers": {
         "Letta": {
             "level": logging.DEBUG if settings.debug else logging.INFO,
-            "handlers": [
-                "console",
-                "file",
-            ],
-            "propagate": False,
+            "propagate": True,  # Let logs bubble up to root
         },
         "uvicorn": {
             "level": "CRITICAL",

letta/metadata.py

@@ -2,6 +2,7 @@
 
 import os
 import secrets
+import warnings
 from typing import List, Optional
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
@@ -353,8 +354,14 @@ class MetadataStore:
                 raise ValueError(f"Agent with name {agent.name} already exists")
             fields = vars(agent)
             fields["memory"] = agent.memory.to_dict()
-            del fields["_internal_memory"]
-            del fields["tags"]
+            if "_internal_memory" in fields:
+                del fields["_internal_memory"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            if "tags" in fields:
+                del fields["tags"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no tags field")
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -364,8 +371,14 @@ class MetadataStore:
             fields = vars(agent)
             if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
                 fields["memory"] = agent.memory.to_dict()
-            del fields["_internal_memory"]
-            del fields["tags"]
+            if "_internal_memory" in fields:
+                del fields["_internal_memory"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            if "tags" in fields:
+                del fields["tags"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no tags field")
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 

letta/orm/__init__.py

@@ -1,7 +1,9 @@
 from letta.orm.base import Base
 from letta.orm.block import Block
+from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
 from letta.orm.organization import Organization
+from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.tool import Tool
 from letta.orm.user import User

letta/orm/block.py

@@ -1,8 +1,9 @@
 from typing import TYPE_CHECKING, Optional, Type
 
-from sqlalchemy import JSON, BigInteger, Integer
+from sqlalchemy import JSON, BigInteger, Integer, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.block import Block as PydanticBlock
@@ -17,6 +18,8 @@ class Block(OrganizationMixin, SqlalchemyBase):
 
     __tablename__ = "block"
     __pydantic_model__ = PydanticBlock
+    # This may seem redundant, but is necessary for the BlocksAgents composite FK relationship
+    __table_args__ = (UniqueConstraint("id", "label", name="unique_block_id_label"),)
 
     template_name: Mapped[Optional[str]] = mapped_column(
         nullable=True, doc="the unique name that identifies a block in a human-readable way"
@@ -27,7 +30,7 @@ class Block(OrganizationMixin, SqlalchemyBase):
         doc="whether the block is a template (e.g. saved human/persona options as baselines for other templates)", default=False
     )
     value: Mapped[str] = mapped_column(doc="Text content of the block for the respective section of core memory.")
-    limit: Mapped[BigInteger] = mapped_column(Integer, default=2000, doc="Character limit of the block.")
+    limit: Mapped[BigInteger] = mapped_column(Integer, default=CORE_MEMORY_BLOCK_CHAR_LIMIT, doc="Character limit of the block.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default={}, doc="arbitrary information related to the block.")
 
     # relationships

letta/orm/blocks_agents.py

@@ -0,0 +1,29 @@
+from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.blocks_agents import BlocksAgents as PydanticBlocksAgents
+
+
+class BlocksAgents(SqlalchemyBase):
+    """Agents must have one or many blocks to make up their core memory."""
+
+    __tablename__ = "blocks_agents"
+    __pydantic_model__ = PydanticBlocksAgents
+    __table_args__ = (
+        UniqueConstraint(
+            "agent_id",
+            "block_label",
+            name="unique_label_per_agent",
+        ),
+        ForeignKeyConstraint(
+            ["block_id", "block_label"],
+            ["block.id", "block.label"],
+            name="fk_block_id_label",
+        ),
+    )
+
+    # unique agent + block label
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    block_id: Mapped[str] = mapped_column(String, primary_key=True)
+    block_label: Mapped[str] = mapped_column(String, primary_key=True)

letta/orm/mixins.py

@@ -37,3 +37,11 @@ class SourceMixin(Base):
     __abstract__ = True
 
     source_id: Mapped[str] = mapped_column(String, ForeignKey("sources.id"))
+
+
+class SandboxConfigMixin(Base):
+    """Mixin for models that belong to a SandboxConfig."""
+
+    __abstract__ = True
+
+    sandbox_config_id: Mapped[str] = mapped_column(String, ForeignKey("sandbox_configs.id"))

letta/orm/organization.py

@@ -2,12 +2,12 @@ from typing import TYPE_CHECKING, List
 
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.file import FileMetadata
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.organization import Organization as PydanticOrganization
 
 if TYPE_CHECKING:
 
+    from letta.orm.file import FileMetadata
     from letta.orm.tool import Tool
     from letta.orm.user import User
 
@@ -27,6 +27,13 @@ class Organization(SqlalchemyBase):
     sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
     agents_tags: Mapped[List["AgentsTags"]] = relationship("AgentsTags", back_populates="organization", cascade="all, delete-orphan")
     files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="organization", cascade="all, delete-orphan")
+    sandbox_configs: Mapped[List["SandboxConfig"]] = relationship(
+        "SandboxConfig", back_populates="organization", cascade="all, delete-orphan"
+    )
+    sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
+        "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
+    )
+
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion
     # agents: Mapped[List["Agent"]] = relationship("Agent", back_populates="organization", cascade="all, delete-orphan")

letta/orm/sandbox_config.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from sqlalchemy import JSON
+from sqlalchemy import Enum as SqlEnum
+from sqlalchemy import String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin, SandboxConfigMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
+from letta.schemas.sandbox_config import (
+    SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable,
+)
+from letta.schemas.sandbox_config import SandboxType
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class SandboxConfig(SqlalchemyBase, OrganizationMixin):
+    """ORM model for sandbox configurations with JSON storage for arbitrary config data."""
+
+    __tablename__ = "sandbox_configs"
+    __pydantic_model__ = PydanticSandboxConfig
+
+    # For now, we only allow one type of sandbox config per organization
+    __table_args__ = (UniqueConstraint("type", "organization_id", name="uix_type_organization"),)
+
+    id: Mapped[str] = mapped_column(String, primary_key=True, nullable=False)
+    type: Mapped[SandboxType] = mapped_column(SqlEnum(SandboxType), nullable=False, doc="The type of sandbox.")
+    config: Mapped[Dict] = mapped_column(JSON, nullable=False, doc="The JSON configuration data.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="sandbox_configs")
+    sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
+        "SandboxEnvironmentVariable", back_populates="sandbox_config", cascade="all, delete-orphan"
+    )
+
+
+class SandboxEnvironmentVariable(SqlalchemyBase, OrganizationMixin, SandboxConfigMixin):
+    """ORM model for environment variables associated with sandboxes."""
+
+    __tablename__ = "sandbox_environment_variables"
+    __pydantic_model__ = PydanticSandboxEnvironmentVariable
+
+    # We cannot have duplicate key names in the same sandbox, the env var would get overwritten
+    __table_args__ = (UniqueConstraint("key", "sandbox_config_id", name="uix_key_sandbox_config"),)
+
+    id: Mapped[str] = mapped_column(String, primary_key=True, nullable=False)
+    key: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the environment variable.")
+    value: Mapped[str] = mapped_column(String, nullable=False, doc="The value of the environment variable.")
+    description: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="An optional description of the environment variable.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="sandbox_environment_variables")
+    sandbox_config: Mapped["SandboxConfig"] = relationship("SandboxConfig", back_populates="sandbox_environment_variables")

letta/orm/sqlalchemy_base.py

@@ -11,7 +11,6 @@ if TYPE_CHECKING:
     from pydantic import BaseModel
     from sqlalchemy.orm import Session
 
-    # from letta.orm.user import User
 
 logger = get_logger(__name__)
 
@@ -28,6 +27,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         cls, *, db_session: "Session", cursor: Optional[str] = None, limit: Optional[int] = 50, **kwargs
     ) -> List[Type["SqlalchemyBase"]]:
         """List records with optional cursor (for pagination) and limit."""
+        logger.debug(f"Listing {cls.__name__} with kwarg filters {kwargs}")
         with db_session as session:
             # Start with the base query filtered by kwargs
             query = select(cls).filter_by(**kwargs)
@@ -67,6 +67,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         Raises:
             NoResultFound: if the object is not found
         """
+        logger.debug(f"Reading {cls.__name__} with ID: {identifier} with actor={actor}")
+
         # Start the query
         query = select(cls)
         # Collect query conditions for better error reporting
@@ -96,6 +98,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         raise NoResultFound(f"{cls.__name__} not found with {conditions_str}")
 
     def create(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        logger.debug(f"Creating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
+
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
 
@@ -106,6 +110,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return self
 
     def delete(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
+
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
 
@@ -114,8 +120,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     def hard_delete(self, db_session: "Session", actor: Optional["User"] = None) -> None:
         """Permanently removes the record from the database."""
-        if actor:
-            logger.info(f"User {actor.id} requested hard deletion of {self.__class__.__name__} with ID {self.id}")
+        logger.debug(f"Hard deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
 
         with db_session as session:
             try:
@@ -129,6 +134,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 logger.info(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
 
     def update(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        logger.debug(f"Updating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
 

letta/schemas/block.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from pydantic import Field, model_validator
+from pydantic import BaseModel, Field, model_validator
 from typing_extensions import Self
 
 from letta.schemas.letta_base import LettaBase
@@ -95,6 +95,13 @@ class BlockCreate(BaseBlock):
     label: str = Field(..., description="Label of the block.")
 
 
+class BlockLabelUpdate(BaseModel):
+    """Update the label of a block"""
+
+    current_label: str = Field(..., description="Current label of the block.")
+    new_label: str = Field(..., description="New label of the block.")
+
+
 class CreatePersona(BlockCreate):
     """Create a persona block"""
 
@@ -117,6 +124,13 @@ class BlockUpdate(BaseBlock):
         extra = "ignore"  # Ignores extra fields
 
 
+class BlockLimitUpdate(BaseModel):
+    """Update the limit of a block"""
+
+    label: str = Field(..., description="Label of the block.")
+    limit: int = Field(..., description="New limit of the block.")
+
+
 class UpdatePersona(BlockUpdate):
     """Update a persona block"""
 

letta/schemas/blocks_agents.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class BlocksAgentsBase(LettaBase):
+    __id_prefix__ = "blocks_agents"
+
+
+class BlocksAgents(BlocksAgentsBase):
+    """
+    Schema representing the relationship between blocks and agents.
+
+    Parameters:
+        agent_id (str): The ID of the associated agent.
+        block_id (str): The ID of the associated block.
+        block_label (str): The label of the block.
+        created_at (datetime): The date this relationship was created.
+        updated_at (datetime): The date this relationship was last updated.
+        is_deleted (bool): Whether this block-agent relationship is deleted or not.
+    """
+
+    id: str = BlocksAgentsBase.generate_id_field()
+    agent_id: str = Field(..., description="The ID of the associated agent.")
+    block_id: str = Field(..., description="The ID of the associated block.")
+    block_label: str = Field(..., description="The label of the block.")
+    created_at: Optional[datetime] = Field(None, description="The creation date of the association.")
+    updated_at: Optional[datetime] = Field(None, description="The update date of the association.")
+    is_deleted: bool = Field(False, description="Whether this block-agent relationship is deleted or not.")

letta/schemas/letta_base.py

@@ -1,4 +1,5 @@
 import uuid
+from datetime import datetime
 from logging import getLogger
 from typing import Optional
 from uuid import UUID
@@ -80,3 +81,11 @@ class LettaBase(BaseModel):
             logger.warning(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
             return f"{cls.__id_prefix__}-{v}"
         return v
+
+
+class OrmMetadataBase(LettaBase):
+    # metadata fields
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this object.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this object.")
+    created_at: Optional[datetime] = Field(None, description="The timestamp when the object was created.")
+    updated_at: Optional[datetime] = Field(None, description="The timestamp when the object was last updated.")