letta-nightly 0.5.4.dev20241125104219__tar.gz → 0.5.4.dev20241127104220__tar.gz

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.4.dev20241125104219
+Version: 0.5.4.dev20241127104220
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/agent.py

@@ -1325,6 +1325,12 @@ class Agent(BaseAgent):
 
     def update_state(self) -> AgentState:
         message_ids = [msg.id for msg in self._messages]
+
+        # Assert that these are all strings
+        if any(not isinstance(m_id, str) for m_id in message_ids):
+            warnings.warn(f"Non-string message IDs found in agent state: {message_ids}")
+            message_ids = [m_id for m_id in message_ids if isinstance(m_id, str)]
+
         assert isinstance(self.memory, Memory), f"Memory is not a Memory object: {type(self.memory)}"
 
         # override any fields that may have been updated

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/cli/cli_config.py

@@ -136,7 +136,7 @@ def add_tool(
     func = eval(func_def.name)
 
     # 4. Add or update the tool
-    tool = client.create_tool(func=func, name=name, tags=tags, update=update)
+    tool = client.create_or_update_tool(func=func, name=name, tags=tags, update=update)
     print(f"Tool {tool.name} added successfully")
 
 

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/client/client.py

@@ -211,6 +211,14 @@ class AbstractClient(object):
     ) -> Tool:
         raise NotImplementedError
 
+    def create_or_update_tool(
+        self,
+        func,
+        name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> Tool:
+        raise NotImplementedError
+
     def update_tool(
         self,
         id: str,
@@ -532,7 +540,7 @@ class RESTClient(AbstractClient):
         # add memory tools
         memory_functions = get_memory_functions(memory)
         for func_name, func in memory_functions.items():
-            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"])
+            tool = self.create_or_update_tool(func, name=func_name, tags=["memory", "letta-base"])
             tool_names.append(tool.name)
 
         # check if default configs are provided
@@ -1440,18 +1448,39 @@ class RESTClient(AbstractClient):
         Returns:
             tool (Tool): The created tool.
         """
+        source_code = parse_source_code(func)
+        source_type = "python"
 
-        # TODO: check tool update code
-        # TODO: check if tool already exists
+        # call server function
+        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
+        response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to create tool: {response.text}")
+        return Tool(**response.json())
 
-        # TODO: how to load modules?
-        # parse source code/schema
+    def create_or_update_tool(
+        self,
+        func: Callable,
+        name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> Tool:
+        """
+        Creates or updates a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
+
+        Args:
+            func (callable): The function to create a tool for.
+            name: (str): Name of the tool (must be unique per-user.)
+            tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
+
+        Returns:
+            tool (Tool): The created tool.
+        """
         source_code = parse_source_code(func)
         source_type = "python"
 
         # call server function
         request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
-        response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
+        response = requests.put(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create tool: {response.text}")
         return Tool(**response.json())
@@ -1489,45 +1518,6 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to update tool: {response.text}")
         return Tool(**response.json())
 
-    # def create_tool(
-    #    self,
-    #    func,
-    #    name: Optional[str] = None,
-    #    update: Optional[bool] = True,  # TODO: actually use this
-    #    tags: Optional[List[str]] = None,
-    # ):
-    #    """Create a tool
-
-    #    Args:
-    #        func (callable): The function to create a tool for.
-    #        tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
-    #        update (bool, optional): Update the tool if it already exists. Defaults to True.
-
-    #    Returns:
-    #        Tool object
-    #    """
-
-    #    # TODO: check if tool already exists
-    #    # TODO: how to load modules?
-    #    # parse source code/schema
-    #    source_code = parse_source_code(func)
-    #    json_schema = generate_schema(func, name)
-    #    source_type = "python"
-    #    json_schema["name"]
-
-    #    # create data
-    #    data = {"source_code": source_code, "source_type": source_type, "tags": tags, "json_schema": json_schema, "update": update}
-    #    try:
-    #        CreateToolRequest(**data)  # validate data
-    #    except Exception as e:
-    #        raise ValueError(f"Failed to create tool: {e}, invalid input {data}")
-
-    #    # make REST request
-    #    response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=data, headers=self.headers)
-    #    if response.status_code != 200:
-    #        raise ValueError(f"Failed to create tool: {response.text}")
-    #    return ToolModel(**response.json())
-
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         """
         List available tools for the user.
@@ -1977,7 +1967,7 @@ class LocalClient(AbstractClient):
         # add memory tools
         memory_functions = get_memory_functions(memory)
         for func_name, func in memory_functions.items():
-            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"])
+            tool = self.create_or_update_tool(func, name=func_name, tags=["memory", "letta-base"])
             tool_names.append(tool.name)
 
         self.interface.clear()
@@ -2573,7 +2563,6 @@ class LocalClient(AbstractClient):
         tool_create = ToolCreate.from_composio(action=action)
         return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
-    # TODO: Use the above function `add_tool` here as there is duplicate logic
     def create_tool(
         self,
         func,
@@ -2601,6 +2590,42 @@ class LocalClient(AbstractClient):
         if not tags:
             tags = []
 
+        # call server function
+        return self.server.tool_manager.create_tool(
+            Tool(
+                source_type=source_type,
+                source_code=source_code,
+                name=name,
+                tags=tags,
+                description=description,
+            ),
+            actor=self.user,
+        )
+
+    def create_or_update_tool(
+        self,
+        func,
+        name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        description: Optional[str] = None,
+    ) -> Tool:
+        """
+        Creates or updates a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
+
+        Args:
+            func (callable): The function to create a tool for.
+            name: (str): Name of the tool (must be unique per-user.)
+            tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
+            description (str, optional): The description.
+
+        Returns:
+            tool (Tool): The created tool.
+        """
+        source_code = parse_source_code(func)
+        source_type = "python"
+        if not tags:
+            tags = []
+
         # call server function
         return self.server.tool_manager.create_or_update_tool(
             Tool(

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/errors.py

@@ -10,6 +10,18 @@ class LettaError(Exception):
     """Base class for all Letta related errors."""
 
 
+class LettaToolCreateError(LettaError):
+    """Error raised when a tool cannot be created."""
+
+    default_error_message = "Error creating tool."
+
+    def __init__(self, message=None):
+        if message is None:
+            message = self.default_error_message
+        self.message = message
+        super().__init__(self.message)
+
+
 class LLMError(LettaError):
     pass
 

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/functions/functions.py

@@ -3,9 +3,10 @@ import inspect
 import os
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Optional, List
+from typing import Dict, List, Optional
 
 from letta.constants import CLI_WARNING_PREFIX
+from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
 
 
@@ -13,10 +14,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
     # auto-generate openai schema
     try:
         # Define a custom environment with necessary imports
-        env = {
-            "Optional": Optional,  # Add any other required imports here
-            "List": List
-        }
+        env = {"Optional": Optional, "List": List, "Dict": Dict}  # Add any other required imports here
 
         env.update(globals())
         exec(source_code, env)
@@ -29,7 +27,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
         json_schema = generate_schema(func, name=name)
         return json_schema
     except Exception as e:
-        raise RuntimeError(f"Failed to execute source code: {e}")
+        raise LettaToolCreateError(f"Failed to derive JSON schema from source code: {e}")
 
 
 def parse_source_code(func) -> str:

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/functions/schema_generator.py

@@ -131,11 +131,12 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
         else:
             # Add parameter details to the schema
             param_doc = next((d for d in docstring.params if d.arg_name == param.name), None)
-            schema["parameters"]["properties"][param.name] = {
-                # "type": "string" if param.annotation == str else str(param.annotation),
-                "type": type_to_json_schema_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
-                "description": param_doc.description,
-            }
+            if param_doc:
+                schema["parameters"]["properties"][param.name] = {
+                    # "type": "string" if param.annotation == str else str(param.annotation),
+                    "type": type_to_json_schema_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
+                    "description": param_doc.description,
+                }
         if param.default == inspect.Parameter.empty:
             schema["parameters"]["required"].append(param.name)
 

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/metadata.py

@@ -25,6 +25,7 @@ from letta.schemas.tool_rule import (
     ToolRule,
 )
 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
 
@@ -383,7 +384,11 @@ class MetadataStore:
             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

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/orm/block.py

@@ -10,7 +10,7 @@ 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):
@@ -35,6 +35,7 @@ class Block(OrganizationMixin, SqlalchemyBase):
 
     # 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_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/orm/blocks_agents.py

@@ -1,5 +1,5 @@
 from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.blocks_agents import BlocksAgents as PydanticBlocksAgents
@@ -27,3 +27,6 @@ class BlocksAgents(SqlalchemyBase):
     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_nightly-0.5.4.dev20241127104220/letta/orm/errors.py

@@ -0,0 +1,14 @@
+class NoResultFound(Exception):
+    """A record or records cannot be found given the provided search params"""
+
+
+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_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/orm/sqlalchemy_base.py

@@ -1,11 +1,16 @@
 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
@@ -102,12 +107,14 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
         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}")
@@ -168,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_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/schemas/block.py

@@ -30,7 +30,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     @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)
 

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/schemas/tool.py

@@ -1,7 +1,8 @@
 from typing import Dict, List, Optional
 
-from pydantic import Field
+from pydantic import Field, model_validator
 
+from letta.functions.functions import derive_openai_json_schema
 from letta.functions.helpers import (
     generate_composio_tool_wrapper,
     generate_langchain_tool_wrapper,
@@ -44,6 +45,29 @@ class Tool(BaseTool):
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
 
+    @model_validator(mode="after")
+    def populate_missing_fields(self):
+        """
+        Populate missing fields: name, description, and json_schema.
+        """
+        # Derive JSON schema if not provided
+        if not self.json_schema:
+            self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+
+        # Derive name from the JSON schema if not provided
+        if not self.name:
+            # TODO: This in theory could error, but name should always be on json_schema
+            # TODO: Make JSON schema a typed pydantic object
+            self.name = self.json_schema.get("name")
+
+        # Derive description from the JSON schema if not provided
+        if not self.description:
+            # TODO: This in theory could error, but description should always be on json_schema
+            # TODO: Make JSON schema a typed pydantic object
+            self.description = self.json_schema.get("description")
+
+        return self
+
     def to_dict(self):
         """
         Convert tool into OpenAI representation.

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/server/rest_api/routers/v1/agents.py

@@ -475,19 +475,21 @@ async def send_message(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    result = await send_message_to_agent(
-        server=server,
-        agent_id=agent_id,
-        user_id=actor.id,
-        messages=request.messages,
-        stream_steps=request.stream_steps,
-        stream_tokens=request.stream_tokens,
-        return_message_object=request.return_message_object,
-        # Support for AssistantMessage
-        use_assistant_message=request.use_assistant_message,
-        assistant_message_function_name=request.assistant_message_function_name,
-        assistant_message_function_kwarg=request.assistant_message_function_kwarg,
-    )
+    agent_lock = server.per_agent_lock_manager.get_lock(agent_id)
+    async with agent_lock:
+        result = await send_message_to_agent(
+            server=server,
+            agent_id=agent_id,
+            user_id=actor.id,
+            messages=request.messages,
+            stream_steps=request.stream_steps,
+            stream_tokens=request.stream_tokens,
+            return_message_object=request.return_message_object,
+            # Support for AssistantMessage
+            use_assistant_message=request.use_assistant_message,
+            assistant_message_function_name=request.assistant_message_function_name,
+            assistant_message_function_kwarg=request.assistant_message_function_kwarg,
+        )
     return result
 
 

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/server/rest_api/routers/v1/tools.py

@@ -2,6 +2,8 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
+from letta.errors import LettaToolCreateError
+from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
@@ -13,12 +15,13 @@ router = APIRouter(prefix="/tools", tags=["tools"])
 def delete_tool(
     tool_id: str,
     server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Delete a tool by name
     """
-    # actor = server.get_user_or_default(user_id=user_id)
-    server.tool_manager.delete_tool(tool_id=tool_id)
+    actor = server.get_user_or_default(user_id=user_id)
+    server.tool_manager.delete_tool_by_id(tool_id=tool_id, actor=actor)
 
 
 @router.get("/{tool_id}", response_model=Tool, operation_id="get_tool")
@@ -83,12 +86,50 @@ def create_tool(
     """
     Create a new tool
     """
-    # Derive user and org id from actor
-    actor = server.get_user_or_default(user_id=user_id)
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        tool = Tool(**request.model_dump())
+        return server.tool_manager.create_tool(pydantic_tool=tool, actor=actor)
+    except UniqueConstraintViolationError as e:
+        # Log or print the full exception here for debugging
+        print(f"Error occurred: {e}")
+        clean_error_message = f"Tool with name {request.name} already exists."
+        raise HTTPException(status_code=409, detail=clean_error_message)
+    except LettaToolCreateError as e:
+        # HTTP 400 == Bad Request
+        print(f"Error occurred during tool creation: {e}")
+        # print the full stack trace
+        import traceback
+
+        print(traceback.format_exc())
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        # Catch other unexpected errors and raise an internal server error
+        print(f"Unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
 
-    # Send request to create the tool
-    tool = Tool(**request.model_dump())
-    return server.tool_manager.create_or_update_tool(pydantic_tool=tool, actor=actor)
+@router.put("/", response_model=Tool, operation_id="upsert_tool")
+def upsert_tool(
+    request: ToolCreate = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Create or update a tool
+    """
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        tool = server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**request.model_dump()), actor=actor)
+        return tool
+    except UniqueConstraintViolationError as e:
+        # Log the error and raise a conflict exception
+        print(f"Unique constraint violation occurred: {e}")
+        raise HTTPException(status_code=409, detail=str(e))
+    except Exception as e:
+        # Catch other unexpected errors and raise an internal server error
+        print(f"Unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241127104220}/letta/server/server.py

@@ -3,6 +3,7 @@ import os
 import traceback
 import warnings
 from abc import abstractmethod
+from asyncio import Lock
 from datetime import datetime
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
@@ -79,6 +80,7 @@ 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.per_agent_lock_manager import PerAgentLockManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
@@ -231,6 +233,9 @@ class SyncServer(Server):
 
         self.credentials = LettaCredentials.load()
 
+        # Locks
+        self.send_message_lock = Lock()
+
         # Initialize the metadata store
         config = LettaConfig.load()
         if settings.letta_pg_uri_no_default:
@@ -252,6 +257,9 @@ class SyncServer(Server):
         self.blocks_agents_manager = BlocksAgentsManager()
         self.sandbox_config_manager = SandboxConfigManager(tool_settings)
 
+        # Managers that interface with parallelism
+        self.per_agent_lock_manager = PerAgentLockManager()
+
         # Make default user and org
         if init_with_default_org_and_user:
             self.default_org = self.organization_manager.create_default_organization()
@@ -925,7 +933,7 @@ class SyncServer(Server):
             logger.exception(e)
             try:
                 if agent:
-                    self.ms.delete_agent(agent_id=agent.agent_state.id)
+                    self.ms.delete_agent(agent_id=agent.agent_state.id, per_agent_lock_manager=self.per_agent_lock_manager)
             except Exception as delete_e:
                 logger.exception(f"Failed to delete_agent:\n{delete_e}")
             raise e
@@ -1522,7 +1530,7 @@ class SyncServer(Server):
 
         # Next, attempt to delete it from the actual database
         try:
-            self.ms.delete_agent(agent_id=agent_id)
+            self.ms.delete_agent(agent_id=agent_id, per_agent_lock_manager=self.per_agent_lock_manager)
         except Exception as e:
             logger.exception(f"Failed to delete agent {agent_id} via ID with:\n{str(e)}")
             raise ValueError(f"Failed to delete agent {agent_id} in database")