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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.4.dev20241125104219
+Version: 0.5.4.dev20241126104249
 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.dev20241126104249}/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.dev20241126104249}/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.dev20241126104249}/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.dev20241126104249/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.dev20241126104249}/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,38 @@ 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
+
+        # 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.dev20241126104249}/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.dev20241126104249}/letta/server/rest_api/routers/v1/tools.py

@@ -2,6 +2,7 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
+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
@@ -83,12 +84,41 @@ 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}")
+        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)}")
 
-    # 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.dev20241126104249}/letta/services/tool_manager.py

@@ -35,9 +35,7 @@ class ToolManager:
     def create_or_update_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Derive json_schema
-        derived_json_schema = pydantic_tool.json_schema or derive_openai_json_schema(source_code=pydantic_tool.source_code)
-        derived_name = pydantic_tool.name or derived_json_schema["name"]
-        tool = self.get_tool_by_name(tool_name=derived_name, actor=actor)
+        tool = self.get_tool_by_name(tool_name=pydantic_tool.name, actor=actor)
         if tool:
             # Put to dict and remove fields that should not be reset
             update_data = pydantic_tool.model_dump(exclude={"module"}, exclude_unset=True, exclude_none=True)
@@ -52,8 +50,6 @@ class ToolManager:
                     f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={pydantic_tool.name}, but found existing tool with nothing to update."
                 )
         else:
-            pydantic_tool.json_schema = derived_json_schema
-            pydantic_tool.name = derived_name
             tool = self.create_tool(pydantic_tool, actor=actor)
 
         return tool
@@ -61,18 +57,15 @@ class ToolManager:
     @enforce_types
     def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
-        # Create the tool
         with self.session_maker() as session:
             # Set the organization id at the ORM layer
             pydantic_tool.organization_id = actor.organization_id
+            # Auto-generate description if not provided
+            if pydantic_tool.description is None:
+                pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
             tool_data = pydantic_tool.model_dump()
             tool = ToolModel(**tool_data)
-            # The description is most likely auto-generated via the json_schema,
-            # so copy it over into the top-level description field
-            if tool.description is None:
-                tool.description = tool.json_schema.get("description", None)
-            tool.create(session, actor=actor)
-
+            tool.create(session, actor=actor)  # Re-raise other database-related errors
         return tool.to_pydantic()
 
     @enforce_types

{letta_nightly-0.5.4.dev20241125104219 → letta_nightly-0.5.4.dev20241126104249}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.5.4.dev20241125104219"
+version = "0.5.4.dev20241126104249"
 packages = [
     {include = "letta"}
 ]

letta_nightly-0.5.4.dev20241125104219/letta/orm/errors.py

@@ -1,6 +0,0 @@
-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."""