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

letta/helpers/tool_rule_solver.py

@@ -2,11 +2,12 @@ from typing import Dict, List, Optional, Set
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.enums import ToolRuleType
 from letta.schemas.tool_rule import (
     BaseToolRule,
+    ChildToolRule,
     InitToolRule,
     TerminalToolRule,
-    ToolRule,
 )
 
 
@@ -21,7 +22,7 @@ class ToolRulesSolver(BaseModel):
     init_tool_rules: List[InitToolRule] = Field(
         default_factory=list, description="Initial tool rules to be used at the start of tool execution."
     )
-    tool_rules: List[ToolRule] = Field(
+    tool_rules: List[ChildToolRule] = Field(
         default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
     )
     terminal_tool_rules: List[TerminalToolRule] = Field(
@@ -33,11 +34,11 @@ class ToolRulesSolver(BaseModel):
         super().__init__(**kwargs)
         # Separate the provided tool rules into init, standard, and terminal categories
         for rule in tool_rules:
-            if isinstance(rule, InitToolRule):
+            if rule.type == ToolRuleType.run_first:
                 self.init_tool_rules.append(rule)
-            elif isinstance(rule, ToolRule):
+            elif rule.type == ToolRuleType.constrain_child_tools:
                 self.tool_rules.append(rule)
-            elif isinstance(rule, TerminalToolRule):
+            elif rule.type == ToolRuleType.exit_loop:
                 self.terminal_tool_rules.append(rule)
 
         # Validate the tool rules to ensure they form a DAG

letta/llm_api/helpers.py

@@ -11,7 +11,55 @@ from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.utils import json_dumps, printd
 
 
-def convert_to_structured_output(openai_function: dict) -> dict:
+def _convert_to_structured_output_helper(property: dict) -> dict:
+    """Convert a single JSON schema property to structured output format (recursive)"""
+
+    if "type" not in property:
+        raise ValueError(f"Property {property} is missing a type")
+    param_type = property["type"]
+
+    if "description" not in property:
+        # raise ValueError(f"Property {property} is missing a description")
+        param_description = None
+    else:
+        param_description = property["description"]
+
+    if param_type == "object":
+        if "properties" not in property:
+            raise ValueError(f"Property {property} of type object is missing properties")
+        properties = property["properties"]
+        property_dict = {
+            "type": "object",
+            "properties": {k: _convert_to_structured_output_helper(v) for k, v in properties.items()},
+            "additionalProperties": False,
+            "required": list(properties.keys()),
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+    elif param_type == "array":
+        if "items" not in property:
+            raise ValueError(f"Property {property} of type array is missing items")
+        items = property["items"]
+        property_dict = {
+            "type": "array",
+            "items": _convert_to_structured_output_helper(items),
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+    else:
+        property_dict = {
+            "type": param_type,  # simple type
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+
+def convert_to_structured_output(openai_function: dict, allow_optional: bool = False) -> dict:
     """Convert function call objects to structured output objects
 
     See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
@@ -22,17 +70,63 @@ def convert_to_structured_output(openai_function: dict) -> dict:
         "name": openai_function["name"],
         "description": description,
         "strict": True,
-        "parameters": {"type": "object", "properties": {}, "additionalProperties": False, "required": []},
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": False,
+            "required": [],
+        },
     }
 
+    # This code needs to be able to handle nested properties
+    # For example, the param details may have "type" + "description",
+    # but if "type" is "object" we expected "properties", where each property has details
+    # and if "type" is "array" we expect "items": <type>
     for param, details in openai_function["parameters"]["properties"].items():
-        structured_output["parameters"]["properties"][param] = {"type": details["type"], "description": details["description"]}
+
+        param_type = details["type"]
+        description = details["description"]
+
+        if param_type == "object":
+            if "properties" not in details:
+                # Structured outputs requires the properties on dicts be specified ahead of time
+                raise ValueError(f"Property {param} of type object is missing properties")
+            structured_output["parameters"]["properties"][param] = {
+                "type": "object",
+                "description": description,
+                "properties": {k: _convert_to_structured_output_helper(v) for k, v in details["properties"].items()},
+                "additionalProperties": False,
+                "required": list(details["properties"].keys()),
+            }
+
+        elif param_type == "array":
+            structured_output["parameters"]["properties"][param] = {
+                "type": "array",
+                "description": description,
+                "items": _convert_to_structured_output_helper(details["items"]),
+            }
+
+        else:
+            structured_output["parameters"]["properties"][param] = {
+                "type": param_type,  # simple type
+                "description": description,
+            }
 
         if "enum" in details:
             structured_output["parameters"]["properties"][param]["enum"] = details["enum"]
 
-    # Add all properties to required list
-    structured_output["parameters"]["required"] = list(structured_output["parameters"]["properties"].keys())
+    if not allow_optional:
+        # Add all properties to required list
+        structured_output["parameters"]["required"] = list(structured_output["parameters"]["properties"].keys())
+
+    else:
+        # See what parameters exist that aren't required
+        # Those are implied "optional" types
+        # For those types, turn each of them into a union type with "null"
+        # e.g.
+        # "type": "string" -> "type": ["string", "null"]
+        # TODO
+        raise NotImplementedError
 
     return structured_output
 

letta/llm_api/openai.py

@@ -477,7 +477,10 @@ def openai_chat_completions_request_stream(
     if "tools" in data:
         for tool in data["tools"]:
             # tool["strict"] = True
-            tool["function"] = convert_to_structured_output(tool["function"])
+            try:
+                tool["function"] = convert_to_structured_output(tool["function"])
+            except ValueError as e:
+                warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
     # print(f"\n\n\n\nData[tools]: {json.dumps(data['tools'], indent=2)}")
 
@@ -533,7 +536,10 @@ def openai_chat_completions_request(
 
     if "tools" in data:
         for tool in data["tools"]:
-            tool["function"] = convert_to_structured_output(tool["function"])
+            try:
+                tool["function"] = convert_to_structured_output(tool["function"])
+            except ValueError as e:
+                warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
     response_json = make_post_request(url, headers, data)
     return ChatCompletionResponse(**response_json)

letta/local_llm/utils.py

@@ -88,16 +88,21 @@ 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.")
+        from letta.utils import printd
+
+        printd(f"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"]
@@ -118,7 +123,7 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
                                 function_tokens += 3
                                 function_tokens += len(encoding.encode(o))
                         else:
-                            print(f"Warning: not supported field {field}")
+                            warnings.warn(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
                 function_tokens += 11
 
         num_tokens += function_tokens
@@ -212,8 +217,10 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
         # print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
         return num_tokens_from_messages(messages, model="gpt-4-0613")
     else:
-        warnings.warn(
-            f"""num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
+        from letta.utils import printd
+
+        printd(
+            f"num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."
         )
         return num_tokens_from_messages(messages, model="gpt-4-0613")
         # raise NotImplementedError(

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

@@ -189,7 +189,7 @@ def run_agent_loop(
 
                 elif user_input.lower() == "/memory":
                     print(f"\nDumping memory contents:\n")
-                    print(f"{letta_agent.memory.compile()}")
+                    print(f"{letta_agent.agent_state.memory.compile()}")
                     print(f"{letta_agent.persistence_manager.archival_memory.compile()}")
                     print(f"{letta_agent.persistence_manager.recall_memory.compile()}")
                     continue

letta/metadata.py

@@ -2,28 +2,23 @@
 
 import os
 import secrets
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
 from sqlalchemy.sql import func
 
 from letta.config import LettaConfig
 from letta.orm.base import Base
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import PersistedAgentState
 from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, ToolRuleType
 from letta.schemas.job import Job
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import Memory
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
-from letta.schemas.tool_rule import (
-    BaseToolRule,
-    InitToolRule,
-    TerminalToolRule,
-    ToolRule,
-)
+from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
+from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.settings import settings
 from letta.utils import enforce_types, get_utc_time, printd
 
@@ -163,28 +158,35 @@ class ToolRulesColumn(TypeDecorator):
     def load_dialect_impl(self, dialect):
         return dialect.type_descriptor(JSON())
 
-    def process_bind_param(self, value: List[BaseToolRule], dialect):
+    def process_bind_param(self, value, dialect):
         """Convert a list of ToolRules to JSON-serializable format."""
         if value:
-            return [rule.model_dump() for rule in value]
+            data = [rule.model_dump() for rule in value]
+            for d in data:
+                d["type"] = d["type"].value
+
+            for d in data:
+                assert not (d["type"] == "ToolRule" and "children" not in d), "ToolRule does not have children field"
+            return data
         return value
 
-    def process_result_value(self, value, dialect) -> List[BaseToolRule]:
+    def process_result_value(self, value, dialect) -> List[Union[ChildToolRule, InitToolRule, TerminalToolRule]]:
         """Convert JSON back to a list of ToolRules."""
         if value:
             return [self.deserialize_tool_rule(rule_data) for rule_data in value]
         return value
 
     @staticmethod
-    def deserialize_tool_rule(data: dict) -> BaseToolRule:
+    def deserialize_tool_rule(data: dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule]:
         """Deserialize a dictionary to the appropriate ToolRule subclass based on the 'type'."""
-        rule_type = data.get("type")  # Remove 'type' field if it exists since it is a class var
-        if rule_type == "InitToolRule":
+        rule_type = ToolRuleType(data.get("type"))  # Remove 'type' field if it exists since it is a class var
+        if rule_type == ToolRuleType.run_first:
             return InitToolRule(**data)
-        elif rule_type == "TerminalToolRule":
+        elif rule_type == ToolRuleType.exit_loop:
             return TerminalToolRule(**data)
-        elif rule_type == "ToolRule":
-            return ToolRule(**data)
+        elif rule_type == ToolRuleType.constrain_child_tools:
+            rule = ChildToolRule(**data)
+            return rule
         else:
             raise ValueError(f"Unknown tool rule type: {rule_type}")
 
@@ -203,7 +205,6 @@ class AgentModel(Base):
 
     # state (context compilation)
     message_ids = Column(JSON)
-    memory = Column(JSON)
     system = Column(String)
 
     # configs
@@ -215,7 +216,7 @@ class AgentModel(Base):
     metadata_ = Column(JSON)
 
     # tools
-    tools = Column(JSON)
+    tool_names = Column(JSON)
     tool_rules = Column(ToolRulesColumn)
 
     Index(__tablename__ + "_idx_user", user_id),
@@ -223,24 +224,22 @@ class AgentModel(Base):
     def __repr__(self) -> str:
         return f"<Agent(id='{self.id}', name='{self.name}')>"
 
-    def to_record(self) -> AgentState:
-        agent_state = AgentState(
+    def to_record(self) -> PersistedAgentState:
+        agent_state = PersistedAgentState(
             id=self.id,
             user_id=self.user_id,
             name=self.name,
             created_at=self.created_at,
             description=self.description,
             message_ids=self.message_ids,
-            memory=Memory.load(self.memory),  # load dictionary
             system=self.system,
-            tools=self.tools,
+            tool_names=self.tool_names,
             tool_rules=self.tool_rules,
             agent_type=self.agent_type,
             llm_config=self.llm_config,
             embedding_config=self.embedding_config,
             metadata_=self.metadata_,
         )
-        assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         return agent_state
 
 
@@ -345,32 +344,48 @@ class MetadataStore:
             return tokens
 
     @enforce_types
-    def create_agent(self, agent: AgentState):
+    def create_agent(self, agent: PersistedAgentState):
         # insert into agent table
         # make sure agent.name does not already exist for user user_id
         with self.session_maker() as session:
             if session.query(AgentModel).filter(AgentModel.name == agent.name).filter(AgentModel.user_id == agent.user_id).count() > 0:
                 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"]
+            # fields["memory"] = agent.memory.to_dict()
+            # 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()
 
     @enforce_types
-    def update_agent(self, agent: AgentState):
+    def update_agent(self, agent: PersistedAgentState):
         with self.session_maker() as session:
             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 isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
+            #    fields["memory"] = agent.memory.to_dict()
+            # 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()
 
     @enforce_types
-    def delete_agent(self, agent_id: str):
+    def delete_agent(self, agent_id: str, per_agent_lock_manager: PerAgentLockManager):
+        # TODO: Remove this once Agent is on the ORM
+        # TODO: To prevent unbounded growth
+        per_agent_lock_manager.clear_lock(agent_id)
+
         with self.session_maker() as session:
 
             # delete agents
@@ -382,7 +397,7 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def list_agents(self, user_id: str) -> List[AgentState]:
+    def list_agents(self, user_id: str) -> List[PersistedAgentState]:
         with self.session_maker() as session:
             results = session.query(AgentModel).filter(AgentModel.user_id == user_id).all()
             return [r.to_record() for r in results]
@@ -390,7 +405,7 @@ class MetadataStore:
     @enforce_types
     def get_agent(
         self, agent_id: Optional[str] = None, agent_name: Optional[str] = None, user_id: Optional[str] = None
-    ) -> Optional[AgentState]:
+    ) -> Optional[PersistedAgentState]:
         with self.session_maker() as session:
             if agent_id:
                 results = session.query(AgentModel).filter(AgentModel.id == agent_id).all()

letta/o1_agent.py

@@ -6,7 +6,6 @@ from letta.metadata import MetadataStore
 from letta.schemas.agent import AgentState
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
-from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 
@@ -45,13 +44,11 @@ class O1Agent(Agent):
         interface: AgentInterface,
         agent_state: AgentState,
         user: User,
-        tools: List[Tool] = [],
         max_thinking_steps: int = 10,
         first_message_verify_mono: bool = False,
     ):
-        super().__init__(interface, agent_state, tools, user)
+        super().__init__(interface, agent_state, user)
         self.max_thinking_steps = max_thinking_steps
-        self.tools = tools
         self.first_message_verify_mono = first_message_verify_mono
 
     def step(

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,15 +1,16 @@
 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
 from letta.schemas.block import Human, Persona
 
 if TYPE_CHECKING:
-    from letta.orm.organization import Organization
+    from letta.orm import BlocksAgents, Organization
 
 
 class Block(OrganizationMixin, SqlalchemyBase):
@@ -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,11 +30,12 @@ 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
     organization: Mapped[Optional["Organization"]] = relationship("Organization")
+    blocks_agents: Mapped[list["BlocksAgents"]] = relationship("BlocksAgents", back_populates="block", cascade="all, delete")
 
     def to_pydantic(self) -> Type:
         match self.label:

letta/orm/blocks_agents.py

@@ -0,0 +1,32 @@
+from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+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)
+
+    # relationships
+    block: Mapped["Block"] = relationship("Block", back_populates="blocks_agents")

letta/orm/errors.py

@@ -4,3 +4,11 @@ class NoResultFound(Exception):
 
 class MalformedIdError(Exception):
     """An id not in the right format, most likely violating uuid4 format."""
+
+
+class UniqueConstraintViolationError(ValueError):
+    """Custom exception for unique constraint violations."""
+
+
+class ForeignKeyConstraintViolationError(ValueError):
+    """Custom exception for foreign key constraint violations."""

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")