letta-nightly 0.5.5.dev20241122170833__py3-none-any.whl → 0.6.0.dev20241204051808__py3-none-any.whl

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

@@ -1,17 +1,21 @@
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
 
 from sqlalchemy import String, select
+from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
-from letta.orm.errors import NoResultFound
+from letta.orm.errors import (
+    ForeignKeyConstraintViolationError,
+    NoResultFound,
+    UniqueConstraintViolationError,
+)
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
     from sqlalchemy.orm import Session
 
-    # from letta.orm.user import User
 
 logger = get_logger(__name__)
 
@@ -28,6 +32,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 +72,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,16 +103,22 @@ 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)
-
-        with db_session as session:
-            session.add(self)
-            session.commit()
-            session.refresh(self)
-            return self
+        try:
+            with db_session as session:
+                session.add(self)
+                session.commit()
+                session.refresh(self)
+                return self
+        except DBAPIError as e:
+            self._handle_dbapi_error(e)
 
     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 +127,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 +141,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)
 
@@ -162,6 +175,51 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             raise ValueError(f"object {actor} has no organization accessor")
         return query.where(cls.organization_id == org_id, cls.is_deleted == False)
 
+    @classmethod
+    def _handle_dbapi_error(cls, e: DBAPIError):
+        """Handle database errors and raise appropriate custom exceptions."""
+        orig = e.orig  # Extract the original error from the DBAPIError
+        error_code = None
+        error_message = str(orig) if orig else str(e)
+        logger.info(f"Handling DBAPIError: {error_message}")
+
+        # Handle SQLite-specific errors
+        if "UNIQUE constraint failed" in error_message:
+            raise UniqueConstraintViolationError(
+                f"A unique constraint was violated for {cls.__name__}. Check your input for duplicates: {e}"
+            ) from e
+
+        if "FOREIGN KEY constraint failed" in error_message:
+            raise ForeignKeyConstraintViolationError(
+                f"A foreign key constraint was violated for {cls.__name__}. Check your input for missing or invalid references: {e}"
+            ) from e
+
+        # For psycopg2
+        if hasattr(orig, "pgcode"):
+            error_code = orig.pgcode
+        # For pg8000
+        elif hasattr(orig, "args") and len(orig.args) > 0:
+            # The first argument contains the error details as a dictionary
+            err_dict = orig.args[0]
+            if isinstance(err_dict, dict):
+                error_code = err_dict.get("C")  # 'C' is the error code field
+        logger.info(f"Extracted error_code: {error_code}")
+
+        # Handle unique constraint violations
+        if error_code == "23505":
+            raise UniqueConstraintViolationError(
+                f"A unique constraint was violated for {cls.__name__}. Check your input for duplicates: {e}"
+            ) from e
+
+        # Handle foreign key violations
+        if error_code == "23503":
+            raise ForeignKeyConstraintViolationError(
+                f"A foreign key constraint was violated for {cls.__name__}. Check your input for missing or invalid references: {e}"
+            ) from e
+
+        # Re-raise for other unhandled DBAPI errors
+        raise
+
     @property
     def __pydantic_model__(self) -> Type["BaseModel"]:
         raise NotImplementedError("Sqlalchemy models must declare a __pydantic_model__ property to be convertable.")

letta/persistence_manager.py

@@ -121,6 +121,7 @@ class LocalStateManager(PersistenceManager):
         # self.messages = [self.messages[0]] + added_messages + self.messages[1:]
 
         # add to recall memory
+        self.recall_memory.insert_many([m for m in added_messages])
 
     def append_to_messages(self, added_messages: List[Message]):
         # first tag with timestamps

letta/schemas/agent.py

@@ -2,15 +2,18 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, field_validator
 
+from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
-from letta.schemas.tool_rule import BaseToolRule
+from letta.schemas.source import Source
+from letta.schemas.tool import Tool
+from letta.schemas.tool_rule import ToolRule
 
 
 class BaseAgent(LettaBase, validate_assignment=True):
@@ -32,23 +35,8 @@ class AgentType(str, Enum):
     o1_agent = "o1_agent"
 
 
-class AgentState(BaseAgent, validate_assignment=True):
-    """
-    Representation of an agent's state. This is the state of the agent at a given time, and is persisted in the DB backend. The state has all the information needed to recreate a persisted agent.
-
-    Parameters:
-        id (str): The unique identifier of the agent.
-        name (str): The name of the agent (must be unique to the user).
-        created_at (datetime): The datetime the agent was created.
-        message_ids (List[str]): The ids of the messages in the agent's in-context memory.
-        memory (Memory): The in-context memory of the agent.
-        tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
-        system (str): The system prompt used by the agent.
-        llm_config (LLMConfig): The LLM configuration used by the agent.
-        embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
-
-    """
-
+class PersistedAgentState(BaseAgent, validate_assignment=True):
+    # NOTE: this has been changed to represent the data stored in the ORM, NOT what is passed around internally or returned to the user
     id: str = BaseAgent.generate_id_field()
     name: str = Field(..., description="The name of the agent.")
     created_at: datetime = Field(..., description="The datetime the agent was created.", default_factory=datetime.now)
@@ -56,16 +44,12 @@ class AgentState(BaseAgent, validate_assignment=True):
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
 
-    memory: Memory = Field(default_factory=Memory, description="The in-context memory of the agent.")
-
     # tools
-    tools: List[str] = Field(..., description="The tools used by the agent.")
+    # TODO: move to ORM mapping
+    tool_names: List[str] = Field(..., description="The tools used by the agent.")
 
     # tool rules
-    tool_rules: Optional[List[BaseToolRule]] = Field(default=None, description="The list of tool rules.")
-
-    # tags
-    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
+    tool_rules: Optional[List[ToolRule]] = Field(default=None, description="The list of tool rules.")
 
     # system prompt
     system: str = Field(..., description="The system prompt used by the agent.")
@@ -77,40 +61,62 @@ class AgentState(BaseAgent, validate_assignment=True):
     llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
     embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        self._internal_memory = self.memory
+    class Config:
+        arbitrary_types_allowed = True
+        validate_assignment = True
 
-    @model_validator(mode="after")
-    def verify_memory_type(self):
-        try:
-            assert isinstance(self.memory, Memory)
-        except Exception as e:
-            raise e
-        return self
 
-    @property
-    def memory(self) -> Memory:
-        return self._internal_memory
+class AgentState(PersistedAgentState):
+    """
+    Representation of an agent's state. This is the state of the agent at a given time, and is persisted in the DB backend. The state has all the information needed to recreate a persisted agent.
+
+    Parameters:
+        id (str): The unique identifier of the agent.
+        name (str): The name of the agent (must be unique to the user).
+        created_at (datetime): The datetime the agent was created.
+        message_ids (List[str]): The ids of the messages in the agent's in-context memory.
+        memory (Memory): The in-context memory of the agent.
+        tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
+        system (str): The system prompt used by the agent.
+        llm_config (LLMConfig): The LLM configuration used by the agent.
+        embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
 
-    @memory.setter
-    def memory(self, value):
-        if not isinstance(value, Memory):
-            raise TypeError(f"Expected Memory, got {type(value).__name__}")
-        self._internal_memory = value
+    """
 
-    class Config:
-        arbitrary_types_allowed = True
-        validate_assignment = True
+    # NOTE: this is what is returned to the client and also what is used to initialize `Agent`
+
+    # This is an object representing the in-process state of a running `Agent`
+    # Field in this object can be theoretically edited by tools, and will be persisted by the ORM
+    memory: Memory = Field(..., description="The in-context memory of the agent.")
+    tools: List[Tool] = Field(..., description="The tools used by the agent.")
+    sources: List[Source] = Field(..., description="The sources used by the agent.")
+    tags: List[str] = Field(..., description="The tags associated with the agent.")
+    # TODO: add in context message objects
 
+    def to_persisted_agent_state(self) -> PersistedAgentState:
+        # turn back into persisted agent
+        data = self.model_dump()
+        del data["memory"]
+        del data["tools"]
+        del data["sources"]
+        del data["tags"]
+        return PersistedAgentState(**data)
 
-class CreateAgent(BaseAgent):
+
+class CreateAgent(BaseAgent):  #
     # all optional as server can generate defaults
     name: Optional[str] = Field(None, description="The name of the agent.")
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
-    memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
+
+    # memory creation
+    memory_blocks: List[CreateBlock] = Field(
+        # [CreateHuman(), CreatePersona()], description="The blocks to create in the agent's in-context memory."
+        ...,
+        description="The blocks to create in the agent's in-context memory.",
+    )
+
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
-    tool_rules: Optional[List[BaseToolRule]] = Field(None, description="The tool rules governing the agent.")
+    tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
@@ -151,7 +157,7 @@ class CreateAgent(BaseAgent):
 class UpdateAgentState(BaseAgent):
     id: str = Field(..., description="The id of the agent.")
     name: Optional[str] = Field(None, description="The name of the agent.")
-    tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tool_names: Optional[List[str]] = Field(None, description="The tools used by the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
@@ -159,7 +165,6 @@ class UpdateAgentState(BaseAgent):
 
     # TODO: determine if these should be editable via this schema?
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
-    memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
 
 
 class AgentStepResponse(BaseModel):

letta/schemas/block.py

@@ -1,8 +1,9 @@
 from typing import Optional
 
-from pydantic import Field, model_validator
+from pydantic import BaseModel, Field, model_validator
 from typing_extensions import Self
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.letta_base import LettaBase
 
 # block of the LLM context
@@ -15,7 +16,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     # data value
     value: str = Field(..., description="Value of the block.")
-    limit: int = Field(2000, description="Character limit of the block.")
+    limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
 
     # template data (optional)
     template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
@@ -28,17 +29,20 @@ class BaseBlock(LettaBase, validate_assignment=True):
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata_: Optional[dict] = Field({}, description="Metadata of the block.")
 
+    # def __len__(self):
+    #     return len(self.value)
+
+    class Config:
+        extra = "ignore"  # Ignores extra fields
+
     @model_validator(mode="after")
     def verify_char_limit(self) -> Self:
-        if len(self.value) > self.limit:
+        if self.value and len(self.value) > self.limit:
             error_msg = f"Edit failed: Exceeds {self.limit} character limit (requested {len(self.value)}) - {str(self)}."
             raise ValueError(error_msg)
 
         return self
 
-    # def __len__(self):
-    #     return len(self.value)
-
     def __setattr__(self, name, value):
         """Run validation if self.value is updated"""
         super().__setattr__(name, value)
@@ -46,9 +50,6 @@ class BaseBlock(LettaBase, validate_assignment=True):
             # run validation
             self.__class__.model_validate(self.model_dump(exclude_unset=True))
 
-    class Config:
-        extra = "ignore"  # Ignores extra fields
-
 
 class Block(BaseBlock):
     """
@@ -88,42 +89,100 @@ class Persona(Block):
     label: str = "persona"
 
 
-class BlockCreate(BaseBlock):
-    """Create a block"""
-
-    is_template: bool = True
-    label: str = Field(..., description="Label of the block.")
+# class CreateBlock(BaseBlock):
+#    """Create a block"""
+#
+#    is_template: bool = True
+#    label: str = Field(..., description="Label of the block.")
 
 
-class CreatePersona(BlockCreate):
-    """Create a persona block"""
+class BlockLabelUpdate(BaseModel):
+    """Update the label of a block"""
 
-    label: str = "persona"
+    current_label: str = Field(..., description="Current label of the block.")
+    new_label: str = Field(..., description="New label of the block.")
 
 
-class CreateHuman(BlockCreate):
-    """Create a human block"""
-
-    label: str = "human"
+# class CreatePersona(CreateBlock):
+#    """Create a persona block"""
+#
+#    label: str = "persona"
+#
+#
+# class CreateHuman(CreateBlock):
+#    """Create a human block"""
+#
+#    label: str = "human"
 
 
 class BlockUpdate(BaseBlock):
     """Update a block"""
 
-    limit: Optional[int] = Field(2000, description="Character limit of the block.")
+    limit: Optional[int] = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
     value: Optional[str] = Field(None, description="Value of the block.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields
 
 
-class UpdatePersona(BlockUpdate):
-    """Update a persona block"""
+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"""
+#
+#    label: str = "persona"
+#
+#
+# class UpdateHuman(BlockUpdate):
+#    """Update a human block"""
+#
+#    label: str = "human"
+
+
+class CreateBlock(BaseBlock):
+    """Create a block"""
+
+    label: str = Field(..., description="Label of the block.")
+    limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
+    value: str = Field(..., description="Value of the block.")
+
+    # block templates
+    is_template: bool = False
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
+
+
+class CreateHuman(CreateBlock):
+    """Create a human block"""
+
+    label: str = "human"
+
+
+class CreatePersona(CreateBlock):
+    """Create a persona block"""
 
     label: str = "persona"
 
 
-class UpdateHuman(BlockUpdate):
-    """Update a human block"""
+class CreateBlockTemplate(CreateBlock):
+    """Create a block template"""
+
+    is_template: bool = True
+
+
+class CreateHumanBlockTemplate(CreateHuman):
+    """Create a human block template"""
 
+    is_template: bool = True
     label: str = "human"
+
+
+class CreatePersonaBlockTemplate(CreatePersona):
+    """Create a persona block template"""
+
+    is_template: bool = True
+    label: str = "persona"

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/enums.py

@@ -33,3 +33,17 @@ class MessageStreamStatus(str, Enum):
     done_generation = "[DONE_GEN]"
     done_step = "[DONE_STEP]"
     done = "[DONE]"
+
+
+class ToolRuleType(str, Enum):
+    """
+    Type of tool rule.
+    """
+
+    # note: some of these should be renamed when we do the data migration
+
+    run_first = "InitToolRule"
+    exit_loop = "TerminalToolRule"  # reasoning loop should exit
+    continue_loop = "continue_loop"  # reasoning loop should continue
+    constrain_child_tools = "ToolRule"
+    require_parent_tools = "require_parent_tools"

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
@@ -62,7 +63,7 @@ class LettaBase(BaseModel):
     @classmethod
     def _id_example(cls, prefix: str):
         """generates an example id for a given prefix"""
-        return [prefix + "-123e4567-e89b-12d3-a456-426614174000"]
+        return f"{prefix}-123e4567-e89b-12d3-a456-426614174000"
 
     @classmethod
     def _id_description(cls, prefix: str):
@@ -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.")

letta/schemas/letta_request.py

@@ -8,33 +8,21 @@ from letta.schemas.message import Message, MessageCreate
 
 class LettaRequest(BaseModel):
     messages: Union[List[MessageCreate], List[Message]] = Field(..., description="The messages to be sent to the agent.")
-    run_async: bool = Field(default=False, description="Whether to asynchronously send the messages to the agent.")  # TODO: implement
-
-    stream_steps: bool = Field(
-        default=False, description="Flag to determine if the response should be streamed. Set to True for streaming agent steps."
-    )
-    stream_tokens: bool = Field(
-        default=False,
-        description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
-    )
-
-    return_message_object: bool = Field(
-        default=False,
-        description="Set True to return the raw Message object. Set False to return the Message in the format of the Letta API.",
-    )
 
     # Flags to support the use of AssistantMessage message types
 
-    use_assistant_message: bool = Field(
-        default=False,
-        description="[Only applicable if return_message_object is False] If true, returns AssistantMessage objects when the agent calls a designated message tool. If false, return FunctionCallMessage objects for all tool calls.",
-    )
-
-    assistant_message_function_name: str = Field(
+    assistant_message_tool_name: str = Field(
         default=DEFAULT_MESSAGE_TOOL,
-        description="[Only applicable if use_assistant_message is True] The name of the designated message tool.",
+        description="The name of the designated message tool.",
     )
-    assistant_message_function_kwarg: str = Field(
+    assistant_message_tool_kwarg: str = Field(
         default=DEFAULT_MESSAGE_TOOL_KWARG,
-        description="[Only applicable if use_assistant_message is True] The name of the message argument in the designated message tool.",
+        description="The name of the message argument in the designated message tool.",
+    )
+
+
+class LettaStreamingRequest(LettaRequest):
+    stream_tokens: bool = Field(
+        default=False,
+        description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
     )