letta-nightly 0.5.4.dev20241122104229__py3-none-any.whl → 0.5.4.dev20241124104049__py3-none-any.whl

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

letta/schemas/memory.py

@@ -5,8 +5,9 @@ from pydantic import BaseModel, Field
 
 # Forward referencing to avoid circular import with Agent -> Memory -> Agent
 if TYPE_CHECKING:
-    from letta.agent import Agent
+    pass
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.block import Block
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import Tool
@@ -229,7 +230,7 @@ class BasicBlockMemory(Memory):
             assert block.label is not None and block.label != "", "each existing chat block must have a name"
             self.link_block(block=block)
 
-    def core_memory_append(self: "Agent", label: str, content: str) -> Optional[str]:  # type: ignore
+    def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
         """
         Append to the contents of core memory.
 
@@ -240,12 +241,12 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
-    def core_memory_replace(self: "Agent", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    def core_memory_replace(agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
         """
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
@@ -257,11 +258,11 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         if old_content not in current_value:
             raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
         new_value = current_value.replace(str(old_content), str(new_content))
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
 
@@ -270,7 +271,7 @@ class ChatMemory(BasicBlockMemory):
     ChatMemory initializes a BaseChatMemory with two default blocks, `human` and `persona`.
     """
 
-    def __init__(self, persona: str, human: str, limit: int = 2000):
+    def __init__(self, persona: str, human: str, limit: int = CORE_MEMORY_BLOCK_CHAR_LIMIT):
         """
         Initialize the ChatMemory object with a persona and human string.
 

letta/schemas/sandbox_config.py

@@ -0,0 +1,114 @@
+import hashlib
+import json
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+
+
+# Sandbox Config
+class SandboxType(str, Enum):
+    E2B = "e2b"
+    LOCAL = "local"
+
+
+class SandboxRunResult(BaseModel):
+    func_return: Optional[Any] = Field(None, description="The function return object")
+    agent_state: Optional[AgentState] = Field(None, description="The agent state")
+    stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the function invocation")
+    sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
+
+
+class LocalSandboxConfig(BaseModel):
+    sandbox_dir: str = Field(..., description="Directory for the sandbox environment.")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.LOCAL
+
+
+class E2BSandboxConfig(BaseModel):
+    timeout: int = Field(5 * 60, description="Time limit for the sandbox (in seconds).")
+    template: Optional[str] = Field(None, description="The E2B template id (docker image).")
+    pip_requirements: Optional[List[str]] = Field(None, description="A list of pip packages to install on the E2B Sandbox")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.E2B
+
+
+class SandboxConfigBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox"
+
+
+class SandboxConfig(SandboxConfigBase):
+    id: str = SandboxConfigBase.generate_id_field()
+    type: SandboxType = Field(None, description="The type of sandbox.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the sandbox.")
+    config: Dict = Field(default_factory=lambda: {}, description="The JSON sandbox settings data.")
+
+    def get_e2b_config(self) -> E2BSandboxConfig:
+        return E2BSandboxConfig(**self.config)
+
+    def get_local_config(self) -> LocalSandboxConfig:
+        return LocalSandboxConfig(**self.config)
+
+    def fingerprint(self) -> str:
+        # Only take into account type, org_id, and the config items
+        # Canonicalize input data into JSON with sorted keys
+        hash_input = json.dumps(
+            {
+                "type": self.type.value,
+                "organization_id": self.organization_id,
+                "config": self.config,
+            },
+            sort_keys=True,  # Ensure stable ordering
+            separators=(",", ":"),  # Minimize serialization differences
+        )
+
+        # Compute SHA-256 hash
+        hash_digest = hashlib.sha256(hash_input.encode("utf-8")).digest()
+
+        # Convert the digest to an integer for compatibility with Python's hash requirements
+        return str(int.from_bytes(hash_digest, byteorder="big"))
+
+
+class SandboxConfigCreate(LettaBase):
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(..., description="The configuration for the sandbox.")
+
+
+class SandboxConfigUpdate(LettaBase):
+    """Pydantic model for updating SandboxConfig fields."""
+
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(None, description="The JSON configuration data for the sandbox.")
+
+
+# Environment Variable
+class SandboxEnvironmentVariableBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox-env"
+
+
+class SandboxEnvironmentVariable(SandboxEnvironmentVariableBase):
+    id: str = SandboxEnvironmentVariableBase.generate_id_field()
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+    sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
+
+
+class SandboxEnvironmentVariableCreate(LettaBase):
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+
+
+class SandboxEnvironmentVariableUpdate(LettaBase):
+    """Pydantic model for updating SandboxEnvironmentVariable fields."""
+
+    key: Optional[str] = Field(None, description="The name of the environment variable.")
+    value: Optional[str] = Field(None, description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")

letta/server/rest_api/routers/v1/__init__.py

@@ -3,15 +3,10 @@ from letta.server.rest_api.routers.v1.blocks import router as blocks_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
+from letta.server.rest_api.routers.v1.sandbox_configs import (
+    router as sandbox_configs_router,
+)
 from letta.server.rest_api.routers.v1.sources import router as sources_router
 from letta.server.rest_api.routers.v1.tools import router as tools_router
 
-ROUTERS = [
-    tools_router,
-    sources_router,
-    agents_router,
-    llm_router,
-    blocks_router,
-    jobs_router,
-    health_router,
-]
+ROUTERS = [tools_router, sources_router, agents_router, llm_router, blocks_router, jobs_router, health_router, sandbox_configs_router]

letta/server/rest_api/routers/v1/sandbox_configs.py

@@ -0,0 +1,108 @@
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, Query
+
+from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
+from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
+from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticEnvVar
+from letta.schemas.sandbox_config import (
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+)
+from letta.server.rest_api.utils import get_letta_server, get_user_id
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/sandbox-config", tags=["sandbox-config"])
+
+
+### Sandbox Config Routes
+
+
+@router.post("/", response_model=PydanticSandboxConfig)
+def create_sandbox_config(
+    config_create: SandboxConfigCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+
+    return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
+
+
+@router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
+def update_sandbox_config(
+    sandbox_config_id: str,
+    config_update: SandboxConfigUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_config(sandbox_config_id, config_update, actor)
+
+
+@router.delete("/{sandbox_config_id}", status_code=204)
+def delete_sandbox_config(
+    sandbox_config_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_config(sandbox_config_id, actor)
+
+
+@router.get("/", response_model=List[PydanticSandboxConfig])
+def list_sandbox_configs(
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_configs(actor, limit=limit, cursor=cursor)
+
+
+### Sandbox Environment Variable Routes
+
+
+@router.post("/{sandbox_config_id}/environment-variable", response_model=PydanticEnvVar)
+def create_sandbox_env_var(
+    sandbox_config_id: str,
+    env_var_create: SandboxEnvironmentVariableCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.create_sandbox_env_var(env_var_create, sandbox_config_id, actor)
+
+
+@router.patch("/environment-variable/{env_var_id}", response_model=PydanticEnvVar)
+def update_sandbox_env_var(
+    env_var_id: str,
+    env_var_update: SandboxEnvironmentVariableUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_env_var(env_var_id, env_var_update, actor)
+
+
+@router.delete("/environment-variable/{env_var_id}", status_code=204)
+def delete_sandbox_env_var(
+    env_var_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_env_var(env_var_id, actor)
+
+
+@router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])
+def list_sandbox_env_vars(
+    sandbox_config_id: str,
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_env_vars(sandbox_config_id, actor, limit=limit, cursor=cursor)

letta/server/rest_api/routers/v1/tools.py

@@ -2,7 +2,6 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
-from letta.orm.errors import NoResultFound
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
@@ -49,11 +48,10 @@ def get_tool_id(
     Get a tool ID by name
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    try:
-        tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    if tool:
         return tool.id
-    except NoResultFound:
+    else:
         raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
 
 

letta/server/rest_api/utils.py

@@ -5,6 +5,7 @@ import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
 
+from fastapi import Header
 from pydantic import BaseModel
 
 from letta.schemas.usage import LettaUsageStatistics
@@ -84,5 +85,10 @@ def get_letta_server() -> SyncServer:
     return server
 
 
+# Dependency to get user_id from headers
+def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optional[str]:
+    return user_id
+
+
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface

letta/server/server.py

@@ -77,7 +77,9 @@ from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agents_tags_manager import AgentsTagsManager
 from letta.services.block_manager import BlockManager
+from letta.services.blocks_agents_manager import BlocksAgentsManager
 from letta.services.organization_manager import OrganizationManager
+from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
@@ -247,6 +249,8 @@ class SyncServer(Server):
         self.block_manager = BlockManager()
         self.source_manager = SourceManager()
         self.agents_tags_manager = AgentsTagsManager()
+        self.blocks_agents_manager = BlocksAgentsManager()
+        self.sandbox_config_manager = SandboxConfigManager(tool_settings)
 
         # Make default user and org
         if init_with_default_org_and_user:
@@ -381,10 +385,11 @@ class SyncServer(Server):
             tool_objs = []
             for name in agent_state.tools:
                 # TODO: This should be a hard failure, but for migration reasons, we patch it for now
-                try:
+                tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
+                if tool_obj:
                     tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
                     tool_objs.append(tool_obj)
-                except NoResultFound:
+                else:
                     warnings.warn(f"Tried to retrieve a tool with name {name} from the agent_state, but does not exist in tool db.")
 
             # set agent_state tools to only the names of the available tools
@@ -837,10 +842,10 @@ class SyncServer(Server):
             tool_objs = []
             if request.tools:
                 for tool_name in request.tools:
-                    try:
-                        tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+                    tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+                    if tool_obj:
                         tool_objs.append(tool_obj)
-                    except NoResultFound:
+                    else:
                         warnings.warn(f"Attempted to add a nonexistent tool {tool_name} to agent {request.name}, skipping.")
             # reset the request.tools to only valid tools
             request.tools = [t.name for t in tool_objs]

letta/services/block_manager.py

@@ -28,13 +28,15 @@ class BlockManager:
             self.update_block(block.id, update_data, actor)
         else:
             with self.session_maker() as session:
+                # Always write the organization_id
+                block.organization_id = actor.organization_id
                 data = block.model_dump(exclude_none=True)
-                block = BlockModel(**data, organization_id=actor.organization_id)
+                block = BlockModel(**data)
                 block.create(session, actor=actor)
             return block.to_pydantic()
 
     @enforce_types
-    def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser, limit: Optional[int] = None) -> PydanticBlock:
+    def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
         """Update a block by its ID with the given BlockUpdate object."""
         with self.session_maker() as session:
             block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)