letta-nightly 0.5.1.dev20241105104128__py3-none-any.whl → 0.5.2.dev20241107104040__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.1"
+__version__ = "0.5.2"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -248,9 +248,21 @@ class Agent(BaseAgent):
         # initialize a tool rules solver
         if agent_state.tool_rules:
             # if there are tool rules, print out a warning
-            warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
+            for rule in agent_state.tool_rules:
+                if not isinstance(rule, TerminalToolRule):
+                    warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
+                    break
         # add default rule for having send_message be a terminal tool
-        agent_state.tool_rules.append(TerminalToolRule(tool_name="send_message"))
+        if agent_state.tool_rules is None:
+            agent_state.tool_rules = []
+        # Define the rule to add
+        send_message_terminal_rule = TerminalToolRule(tool_name="send_message")
+        # Check if an equivalent rule is already present
+        if not any(
+            isinstance(rule, TerminalToolRule) and rule.tool_name == send_message_terminal_rule.tool_name for rule in agent_state.tool_rules
+        ):
+            agent_state.tool_rules.append(send_message_terminal_rule)
+
         self.tool_rules_solver = ToolRulesSolver(tool_rules=agent_state.tool_rules)
 
         # gpt-4, gpt-3.5-turbo, ...
@@ -392,7 +404,6 @@ class Agent(BaseAgent):
                     exec(tool.module, env)
                 else:
                     exec(tool.source_code, env)
-
                 self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
                 self.functions.append(tool.json_schema)
             except Exception as e:
@@ -784,7 +795,6 @@ class Agent(BaseAgent):
 
         # Update ToolRulesSolver state with last called function
         self.tool_rules_solver.update_tool_usage(function_name)
-
         # Update heartbeat request according to provided tool rules
         if self.tool_rules_solver.has_children_tools(function_name):
             heartbeat_request = True

letta/agent_store/db.py

@@ -358,26 +358,26 @@ class PostgresStorageConnector(SQLStorageConnector):
         # construct URI from enviornment variables
         if settings.pg_uri:
             self.uri = settings.pg_uri
+
+        # use config URI
+        # TODO: remove this eventually (config should NOT contain URI)
+        if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
+            self.uri = self.config.archival_storage_uri
+            self.db_model = PassageModel
+            if self.config.archival_storage_uri is None:
+                raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
+        elif table_type == TableType.RECALL_MEMORY:
+            self.uri = self.config.recall_storage_uri
+            self.db_model = MessageModel
+            if self.config.recall_storage_uri is None:
+                raise ValueError(f"Must specify recall_storage_uri in config {self.config.config_path}")
+        elif table_type == TableType.FILES:
+            self.uri = self.config.metadata_storage_uri
+            self.db_model = FileMetadataModel
+            if self.config.metadata_storage_uri is None:
+                raise ValueError(f"Must specify metadata_storage_uri in config {self.config.config_path}")
         else:
-            # use config URI
-            # TODO: remove this eventually (config should NOT contain URI)
-            if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
-                self.uri = self.config.archival_storage_uri
-                self.db_model = PassageModel
-                if self.config.archival_storage_uri is None:
-                    raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
-            elif table_type == TableType.RECALL_MEMORY:
-                self.uri = self.config.recall_storage_uri
-                self.db_model = MessageModel
-                if self.config.recall_storage_uri is None:
-                    raise ValueError(f"Must specify recall_storage_uri in config {self.config.config_path}")
-            elif table_type == TableType.FILES:
-                self.uri = self.config.metadata_storage_uri
-                self.db_model = FileMetadataModel
-                if self.config.metadata_storage_uri is None:
-                    raise ValueError(f"Must specify metadata_storage_uri in config {self.config.config_path}")
-            else:
-                raise ValueError(f"Table type {table_type} not implemented")
+            raise ValueError(f"Table type {table_type} not implemented")
 
         for c in self.db_model.__table__.columns:
             if c.name == "embedding":
@@ -578,4 +578,6 @@ class SQLLiteStorageConnector(SQLStorageConnector):
 def attach_base():
     # This should be invoked in server.py to make sure Base gets initialized properly
     # DO NOT REMOVE
-    print("Initializing database...")
+    from letta.utils import printd
+
+    printd("Initializing database...")

letta/cli/cli.py

@@ -10,7 +10,7 @@ import letta.utils as utils
 from letta import create_client
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
-from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
+from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR, MIN_CONTEXT_WINDOW
 from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL
 from letta.log import get_logger
 from letta.metadata import MetadataStore
@@ -244,6 +244,19 @@ def run(
             llm_model_name = questionary.select("Select LLM model:", choices=llm_choices).ask().model
         llm_config = [llm_config for llm_config in llm_configs if llm_config.model == llm_model_name][0]
 
+        # option to override context window
+        if llm_config.context_window is not None:
+            context_window_validator = lambda x: x.isdigit() and int(x) > MIN_CONTEXT_WINDOW and int(x) <= llm_config.context_window
+            context_window_input = questionary.text(
+                "Select LLM context window limit (hit enter for default):",
+                default=str(llm_config.context_window),
+                validate=context_window_validator,
+            ).ask()
+            if context_window_input is not None:
+                llm_config.context_window = int(context_window_input)
+            else:
+                sys.exit(1)
+
         # choose form list of embedding configs
         embedding_configs = client.list_embedding_configs()
         embedding_options = [embedding_config.embedding_model for embedding_config in embedding_configs]

letta/client/client.py

@@ -77,6 +77,7 @@ class AbstractClient(object):
         memory: Memory = ChatMemory(human=get_human_text(DEFAULT_HUMAN), persona=get_persona_text(DEFAULT_PERSONA)),
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
@@ -333,8 +334,12 @@ class RESTClient(AbstractClient):
         self._default_llm_config = default_llm_config
         self._default_embedding_config = default_embedding_config
 
-    def list_agents(self) -> List[AgentState]:
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers)
+    def list_agents(self, tags: Optional[List[str]] = None) -> List[AgentState]:
+        params = {}
+        if tags:
+            params["tags"] = tags
+
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers, params=params)
         return [AgentState(**agent) for agent in response.json()]
 
     def agent_exists(self, agent_id: str) -> bool:
@@ -372,6 +377,7 @@ class RESTClient(AbstractClient):
         system: Optional[str] = None,
         # tools
         tools: Optional[List[str]] = None,
+        tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
@@ -425,6 +431,7 @@ class RESTClient(AbstractClient):
             metadata_=metadata,
             memory=memory,
             tools=tool_names,
+            tool_rules=tool_rules,
             system=system,
             agent_type=agent_type,
             llm_config=llm_config if llm_config else self._default_llm_config,
@@ -477,6 +484,7 @@ class RESTClient(AbstractClient):
         description: Optional[str] = None,
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
         llm_config: Optional[LLMConfig] = None,
         embedding_config: Optional[EmbeddingConfig] = None,
@@ -506,6 +514,7 @@ class RESTClient(AbstractClient):
             name=name,
             system=system,
             tools=tools,
+            tags=tags,
             description=description,
             metadata_=metadata,
             llm_config=llm_config,
@@ -612,7 +621,12 @@ class RESTClient(AbstractClient):
             agent_id (str): ID of the agent
         """
         # TODO: implement this
-        raise NotImplementedError
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers, params={"name": agent_name})
+        agents = [AgentState(**agent) for agent in response.json()]
+        if len(agents) == 0:
+            return None
+        assert len(agents) == 1, f"Multiple agents with the same name: {agents}"
+        return agents[0].id
 
     # memory
     def get_in_context_memory(self, agent_id: str) -> Memory:
@@ -1609,13 +1623,10 @@ class LocalClient(AbstractClient):
         self.organization = self.server.get_organization_or_default(self.org_id)
 
     # agents
-    def list_agents(self) -> List[AgentState]:
+    def list_agents(self, tags: Optional[List[str]] = None) -> List[AgentState]:
         self.interface.clear()
 
-        # TODO: fix the server function
-        # return self.server.list_agents(user_id=self.user_id)
-
-        return self.server.ms.list_agents(user_id=self.user_id)
+        return self.server.list_agents(user_id=self.user_id, tags=tags)
 
     def agent_exists(self, agent_id: Optional[str] = None, agent_name: Optional[str] = None) -> bool:
         """
@@ -1749,6 +1760,7 @@ class LocalClient(AbstractClient):
         description: Optional[str] = None,
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
         llm_config: Optional[LLMConfig] = None,
         embedding_config: Optional[EmbeddingConfig] = None,
@@ -1780,6 +1792,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 system=system,
                 tools=tools,
+                tags=tags,
                 description=description,
                 metadata_=metadata,
                 llm_config=llm_config,
@@ -1864,7 +1877,7 @@ class LocalClient(AbstractClient):
             agent_state (AgentState): State of the agent
         """
         self.interface.clear()
-        return self.server.get_agent(agent_name=agent_name, user_id=self.user_id, agent_id=None)
+        return self.server.get_agent_state(agent_name=agent_name, user_id=self.user_id, agent_id=None)
 
     def get_agent(self, agent_id: str) -> AgentState:
         """
@@ -2267,18 +2280,18 @@ class LocalClient(AbstractClient):
             langchain_tool=langchain_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
         tool_create = ToolCreate.from_crewai(
             crewai_tool=crewai_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
         tool_create = ToolCreate.from_composio(action=action)
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        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(
@@ -2310,7 +2323,7 @@ class LocalClient(AbstractClient):
 
         # call server function
         return self.server.tool_manager.create_or_update_tool(
-            ToolCreate(
+            Tool(
                 source_type=source_type,
                 source_code=source_code,
                 name=name,
@@ -2738,7 +2751,7 @@ class LocalClient(AbstractClient):
         return self.server.list_embedding_models()
 
     def create_org(self, name: Optional[str] = None) -> Organization:
-        return self.server.organization_manager.create_organization(name=name)
+        return self.server.organization_manager.create_organization(pydantic_org=Organization(name=name))
 
     def list_orgs(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Organization]:
         return self.server.organization_manager.list_organizations(cursor=cursor, limit=limit)

letta/constants.py

@@ -18,6 +18,9 @@ IN_CONTEXT_MEMORY_KEYWORD = "CORE_MEMORY"
 # OpenAI error message: Invalid 'messages[1].tool_calls[0].id': string too long. Expected a string with maximum length 29, but got a string with length 36 instead.
 TOOL_CALL_ID_MAX_LEN = 29
 
+# minimum context window size
+MIN_CONTEXT_WINDOW = 4000
+
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
 

letta/functions/functions.py

@@ -9,7 +9,7 @@ from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
 
 
-def derive_openai_json_schema(source_code: str, name: Optional[str]) -> dict:
+def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
     # auto-generate openai schema
     try:
         # Define a custom environment with necessary imports

letta/helpers/tool_rule_solver.py

@@ -1,4 +1,3 @@
-import warnings
 from typing import Dict, List, Optional, Set
 
 from pydantic import BaseModel, Field
@@ -67,7 +66,7 @@ class ToolRulesSolver(BaseModel):
             if error_on_empty:
                 raise RuntimeError(message)
             else:
-                warnings.warn(message)
+                # warnings.warn(message)
                 return []
 
     def is_terminal_tool(self, tool_name: str) -> bool:

letta/log.py

@@ -56,7 +56,7 @@ DEVELOPMENT_LOGGING = {
             "propagate": False,
         },
         "uvicorn": {
-            "level": "INFO",
+            "level": "CRITICAL",
             "handlers": ["console"],
             "propagate": False,
         },

letta/main.py

@@ -26,6 +26,9 @@ from letta.streaming_interface import AgentRefreshStreamingInterface
 
 # interface = interface()
 
+# disable composio print on exit
+os.environ["COMPOSIO_DISABLE_VERSION_CHECK"] = "true"
+
 app = typer.Typer(pretty_exceptions_enable=False)
 app.command(name="run")(run)
 app.command(name="version")(version)

letta/metadata.py

@@ -493,6 +493,7 @@ class MetadataStore:
             fields = vars(agent)
             fields["memory"] = agent.memory.to_dict()
             del fields["_internal_memory"]
+            del fields["tags"]
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -531,6 +532,7 @@ class MetadataStore:
             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"]
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 

letta/orm/agents_tags.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.agents_tags import AgentsTags as PydanticAgentsTags
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class AgentsTags(SqlalchemyBase, OrganizationMixin):
+    """Associates tags with agents, allowing agents to have multiple tags and supporting tag-based filtering."""
+
+    __tablename__ = "agents_tags"
+    __pydantic_model__ = PydanticAgentsTags
+    __table_args__ = (UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),)
+
+    # The agent associated with this tag
+    agent_id = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+
+    # The name of the tag
+    tag: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the tag associated with the agent.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents_tags")

letta/orm/base.py

@@ -67,7 +67,7 @@ class CommonSqlalchemyMetaMixins(Base):
         prop_value = getattr(self, full_prop, None)
         if not prop_value:
             return
-        return f"user-{prop_value}"
+        return prop_value
 
     def _user_id_setter(self, prop: str, value: str) -> None:
         """returns the user id for the specified property"""
@@ -75,6 +75,9 @@ class CommonSqlalchemyMetaMixins(Base):
         if not value:
             setattr(self, full_prop, None)
             return
+        # Safety check
         prefix, id_ = value.split("-", 1)
         assert prefix == "user", f"{prefix} is not a valid id prefix for a user id"
-        setattr(self, full_prop, id_)
+
+        # Set the full value
+        setattr(self, full_prop, value)

letta/orm/mixins.py

@@ -1,11 +1,9 @@
-from typing import Optional
 from uuid import UUID
 
 from sqlalchemy import ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm.base import Base
-from letta.orm.errors import MalformedIdError
 
 
 def is_valid_uuid4(uuid_string: str) -> bool:
@@ -17,53 +15,12 @@ def is_valid_uuid4(uuid_string: str) -> bool:
         return False
 
 
-def _relation_getter(instance: "Base", prop: str) -> Optional[str]:
-    """Get relation and return id with prefix as a string."""
-    prefix = prop.replace("_", "")
-    formatted_prop = f"_{prop}_id"
-    try:
-        id_ = getattr(instance, formatted_prop)  # Get the string id directly
-        return f"{prefix}-{id_}"
-    except AttributeError:
-        return None
-
-
-def _relation_setter(instance: "Base", prop: str, value: str) -> None:
-    """Set relation using the id with prefix, ensuring the id is a valid UUIDv4."""
-    formatted_prop = f"_{prop}_id"
-    prefix = prop.replace("_", "")
-    if not value:
-        setattr(instance, formatted_prop, None)
-        return
-    try:
-        found_prefix, id_ = value.split("-", 1)
-    except ValueError as e:
-        raise MalformedIdError(f"{value} is not a valid ID.") from e
-
-    # Ensure prefix matches
-    assert found_prefix == prefix, f"{found_prefix} is not a valid id prefix, expecting {prefix}"
-
-    # Validate that the id is a valid UUID4 string
-    if not is_valid_uuid4(id_):
-        raise MalformedIdError(f"Hash segment of {value} is not a valid UUID4")
-
-    setattr(instance, formatted_prop, id_)  # Store id as a string
-
-
 class OrganizationMixin(Base):
     """Mixin for models that belong to an organization."""
 
     __abstract__ = True
 
-    _organization_id: Mapped[str] = mapped_column(String, ForeignKey("organization._id"))
-
-    @property
-    def organization_id(self) -> str:
-        return _relation_getter(self, "organization")
-
-    @organization_id.setter
-    def organization_id(self, value: str) -> None:
-        _relation_setter(self, "organization", value)
+    organization_id: Mapped[str] = mapped_column(String, ForeignKey("organizations.id"))
 
 
 class UserMixin(Base):
@@ -71,12 +28,4 @@ class UserMixin(Base):
 
     __abstract__ = True
 
-    _user_id: Mapped[str] = mapped_column(String, ForeignKey("user._id"))
-
-    @property
-    def user_id(self) -> str:
-        return _relation_getter(self, "user")
-
-    @user_id.setter
-    def user_id(self, value: str) -> None:
-        _relation_setter(self, "user", value)
+    user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))

letta/orm/organization.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, List
 
+from sqlalchemy import String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.sqlalchemy_base import SqlalchemyBase
@@ -14,13 +15,15 @@ if TYPE_CHECKING:
 class Organization(SqlalchemyBase):
     """The highest level of the object tree. All Entities belong to one and only one Organization."""
 
-    __tablename__ = "organization"
+    __tablename__ = "organizations"
     __pydantic_model__ = PydanticOrganization
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(doc="The display name of the organization.")
 
     users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
     tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
+    agents_tags: Mapped[List["AgentsTags"]] = relationship("AgentsTags", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion

letta/orm/sqlalchemy_base.py

@@ -1,14 +1,11 @@
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
-from uuid import uuid4
 
-from humps import depascalize
-from sqlalchemy import Boolean, String, select
+from sqlalchemy import String, select
 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.mixins import is_valid_uuid4
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -24,27 +21,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     __order_by_default__ = "created_at"
 
-    _id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"{uuid4()}")
-
-    deleted: Mapped[bool] = mapped_column(Boolean, default=False, doc="Is this record deleted? Used for universal soft deletes.")
-
-    @classmethod
-    def __prefix__(cls) -> str:
-        return depascalize(cls.__name__)
-
-    @property
-    def id(self) -> Optional[str]:
-        if self._id:
-            return f"{self.__prefix__()}-{self._id}"
-
-    @id.setter
-    def id(self, value: str) -> None:
-        if not value:
-            return
-        prefix, id_ = value.split("-", 1)
-        assert prefix == self.__prefix__(), f"{prefix} is not a valid id prefix for {self.__class__.__name__}"
-        assert is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
-        self._id = id_
+    id: Mapped[str] = mapped_column(String, primary_key=True)
 
     @classmethod
     def list(
@@ -57,11 +34,10 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Add a cursor condition if provided
             if cursor:
-                cursor_uuid = cls.get_uid_from_identifier(cursor)  # Assuming the cursor is an _id value
-                query = query.where(cls._id > cursor_uuid)
+                query = query.where(cls.id > cursor)
 
             # Add a limit to the query if provided
-            query = query.order_by(cls._id).limit(limit)
+            query = query.order_by(cls.id).limit(limit)
 
             # Handle soft deletes if the class has the 'is_deleted' attribute
             if hasattr(cls, "is_deleted"):
@@ -70,20 +46,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             # Execute the query and return the results as a list of model instances
             return list(session.execute(query).scalars())
 
-    @classmethod
-    def get_uid_from_identifier(cls, identifier: str, indifferent: Optional[bool] = False) -> str:
-        """converts the id into a uuid object
-        Args:
-            identifier: the string identifier, such as `organization-xxxx-xx...`
-            indifferent: if True, will not enforce the prefix check
-        """
-        try:
-            uuid_string = identifier.split("-", 1)[1] if indifferent else identifier.replace(f"{cls.__prefix__()}-", "")
-            assert is_valid_uuid4(uuid_string)
-            return uuid_string
-        except ValueError as e:
-            raise ValueError(f"{identifier} is not a valid identifier for class {cls.__name__}") from e
-
     @classmethod
     def read(
         cls,
@@ -112,8 +74,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
         # If an identifier is provided, add it to the query conditions
         if identifier is not None:
-            identifier = cls.get_uid_from_identifier(identifier)
-            query = query.where(cls._id == identifier)
+            query = query.where(cls.id == identifier)
             query_conditions.append(f"id='{identifier}'")
 
         if kwargs:
@@ -151,6 +112,22 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         self.is_deleted = True
         return self.update(db_session)
 
+    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}")
+
+        with db_session as session:
+            try:
+                session.delete(self)
+                session.commit()
+            except Exception as e:
+                session.rollback()
+                logger.exception(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}")
+                raise ValueError(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}: {e}")
+            else:
+                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"]:
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
@@ -183,7 +160,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         org_id = getattr(actor, "organization_id", None)
         if not org_id:
             raise ValueError(f"object {actor} has no organization accessor")
-        return query.where(cls._organization_id == cls.get_uid_from_identifier(org_id, indifferent=True), cls.is_deleted == False)
+        return query.where(cls.organization_id == org_id, cls.is_deleted == False)
 
     @property
     def __pydantic_model__(self) -> Type["BaseModel"]:

letta/orm/tool.py

@@ -21,13 +21,14 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     more granular permissions.
     """
 
-    __tablename__ = "tool"
+    __tablename__ = "tools"
     __pydantic_model__ = PydanticTool
 
     # Add unique constraint on (name, _organization_id)
     # An organization should not have multiple tools with the same name
-    __table_args__ = (UniqueConstraint("name", "_organization_id", name="uix_name_organization"),)
+    __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")

letta/orm/user.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 
+from sqlalchemy import String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -13,9 +14,10 @@ if TYPE_CHECKING:
 class User(SqlalchemyBase, OrganizationMixin):
     """User ORM class"""
 
-    __tablename__ = "user"
+    __tablename__ = "users"
     __pydantic_model__ = PydanticUser
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(nullable=False, doc="The display name of the user.")
 
     # relationships