letta-nightly 0.5.0.dev20241023104105__py3-none-any.whl → 0.5.1.dev20241023193051__py3-none-any.whl

letta/__init__.py

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

letta/constants.py

@@ -4,13 +4,13 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 
 # Defaults
-DEFAULT_USER_ID = "user-00000000"
+DEFAULT_USER_ID = "user-00000000-0000-4000-8000-000000000000"
 # This UUID follows the UUID4 rules:
 # The 13th character (4) indicates it's version 4.
 # The first character of the third segment (8) ensures the variant is correctly set.
 DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
-DEFAULT_USER_NAME = "default"
-DEFAULT_ORG_NAME = "default"
+DEFAULT_USER_NAME = "default_user"
+DEFAULT_ORG_NAME = "default_org"
 
 
 # String in the error message for when the context window is too large

letta/metadata.py

@@ -15,7 +15,6 @@ from sqlalchemy import (
     String,
     TypeDecorator,
     asc,
-    desc,
     or_,
 )
 from sqlalchemy.sql import func
@@ -31,8 +30,6 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
-
-# from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
@@ -154,25 +151,6 @@ class ToolCallColumn(TypeDecorator):
         return value
 
 
-class UserModel(Base):
-    __tablename__ = "users"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    org_id = Column(String)
-    name = Column(String, nullable=False)
-    created_at = Column(DateTime(timezone=True))
-
-    # TODO: what is this?
-    policies_accepted = Column(Boolean, nullable=False, default=False)
-
-    def __repr__(self) -> str:
-        return f"<User(id='{self.id}' name='{self.name}')>"
-
-    def to_record(self) -> User:
-        return User(id=self.id, name=self.name, created_at=self.created_at, org_id=self.org_id)
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"
@@ -497,15 +475,6 @@ class MetadataStore:
             tokens = [r.to_record() for r in results]
             return tokens
 
-    @enforce_types
-    def get_user_from_api_key(self, api_key: str) -> Optional[User]:
-        """Get the user associated with a given API key"""
-        token = self.get_api_key(api_key=api_key)
-        if token is None:
-            raise ValueError(f"Provided token does not exist")
-        else:
-            return self.get_user(user_id=token.user_id)
-
     @enforce_types
     def create_agent(self, agent: AgentState):
         # insert into agent table
@@ -527,14 +496,6 @@ class MetadataStore:
             session.add(SourceModel(**vars(source)))
             session.commit()
 
-    @enforce_types
-    def create_user(self, user: User):
-        with self.session_maker() as session:
-            if session.query(UserModel).filter(UserModel.id == user.id).count() > 0:
-                raise ValueError(f"User with id {user.id} already exists")
-            session.add(UserModel(**vars(user)))
-            session.commit()
-
     @enforce_types
     def create_block(self, block: Block):
         with self.session_maker() as session:
@@ -573,12 +534,6 @@ class MetadataStore:
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
-    @enforce_types
-    def update_user(self, user: User):
-        with self.session_maker() as session:
-            session.query(UserModel).filter(UserModel.id == user.id).update(vars(user))
-            session.commit()
-
     @enforce_types
     def update_source(self, source: Source):
         with self.session_maker() as session:
@@ -657,23 +612,6 @@ class MetadataStore:
 
             session.commit()
 
-    @enforce_types
-    def delete_user(self, user_id: str):
-        with self.session_maker() as session:
-            # delete from users table
-            session.query(UserModel).filter(UserModel.id == user_id).delete()
-
-            # delete associated agents
-            session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()
-
-            # delete associated sources
-            session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()
-
-            # delete associated mappings
-            session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()
-
-            session.commit()
-
     @enforce_types
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
         with self.session_maker() as session:
@@ -719,30 +657,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"  # should only be one result
             return results[0].to_record()
 
-    @enforce_types
-    def get_user(self, user_id: str) -> Optional[User]:
-        with self.session_maker() as session:
-            results = session.query(UserModel).filter(UserModel.id == user_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def get_all_users(self, cursor: Optional[str] = None, limit: Optional[int] = 50):
-        with self.session_maker() as session:
-            query = session.query(UserModel).order_by(desc(UserModel.id))
-            if cursor:
-                query = query.filter(UserModel.id < cursor)
-            results = query.limit(limit).all()
-            if not results:
-                return None, []
-            user_records = [r.to_record() for r in results]
-            next_cursor = user_records[-1].id
-            assert isinstance(next_cursor, str)
-
-            return next_cursor, user_records
-
     @enforce_types
     def get_source(
         self, source_id: Optional[str] = None, user_id: Optional[str] = None, source_name: Optional[str] = None

letta/orm/errors.py

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

letta/orm/mixins.py

@@ -1,24 +1,35 @@
-from typing import Optional, Type
+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
 
 
-class MalformedIdError(Exception):
-    pass
+def is_valid_uuid4(uuid_string: str) -> bool:
+    """Check if a string is a valid UUID4."""
+    try:
+        uuid_obj = UUID(uuid_string)
+        return uuid_obj.version == 4
+    except ValueError:
+        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:
-        uuid_ = getattr(instance, formatted_prop)
-        return f"{prefix}-{uuid_}"
+        id_ = getattr(instance, formatted_prop)  # Get the string id directly
+        return f"{prefix}-{id_}"
     except AttributeError:
         return None
 
 
-def _relation_setter(instance: Type["Base"], prop: str, value: str) -> 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:
@@ -28,13 +39,29 @@ def _relation_setter(instance: Type["Base"], prop: str, value: str) -> None:
         found_prefix, id_ = value.split("-", 1)
     except ValueError as e:
         raise MalformedIdError(f"{value} is not a valid ID.") from e
-    assert (
-        # TODO: should be able to get this from the Mapped typing, not sure how though
-        # prefix = getattr(?, "prefix")
-        found_prefix
-        == prefix
-    ), f"{found_prefix} is not a valid id prefix, expecting {prefix}"
-    try:
-        setattr(instance, formatted_prop, UUID(id_))
-    except ValueError as e:
-        raise MalformedIdError("Hash segment of {value} is not a valid UUID") 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
+
+    # Changed _organization_id to store string (still a valid UUID4 string)
+    _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)

letta/orm/organization.py

@@ -1,35 +1,28 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
-from sqlalchemy.exc import NoResultFound
-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.organization import Organization as PydanticOrganization
 
 if TYPE_CHECKING:
-    from sqlalchemy.orm import Session
+
+    from letta.orm.user import User
 
 
 class Organization(SqlalchemyBase):
     """The highest level of the object tree. All Entities belong to one and only one Organization."""
 
-    __tablename__ = "organizations"
+    __tablename__ = "organization"
     __pydantic_model__ = PydanticOrganization
 
     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")
+
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion
-    # users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
     # agents: Mapped[List["Agent"]] = relationship("Agent", back_populates="organization", cascade="all, delete-orphan")
     # sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
     # tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
     # documents: Mapped[List["Document"]] = relationship("Document", back_populates="organization", cascade="all, delete-orphan")
-
-    @classmethod
-    def default(cls, db_session: "Session") -> "Organization":
-        """Get the default org, or create it if it doesn't exist."""
-        try:
-            return db_session.query(cls).filter(cls.name == "Default Organization").one()
-        except NoResultFound:
-            return cls(name="Default Organization").create(db_session)

letta/orm/sqlalchemy_base.py

@@ -8,6 +8,7 @@ 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
@@ -42,7 +43,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return
         prefix, id_ = value.split("-", 1)
         assert prefix == self.__prefix__(), f"{prefix} is not a valid id prefix for {self.__class__.__name__}"
-        assert SqlalchemyBase.is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
+        assert is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
         self._id = id_
 
     @classmethod
@@ -78,22 +79,11 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         """
         try:
             uuid_string = identifier.split("-", 1)[1] if indifferent else identifier.replace(f"{cls.__prefix__()}-", "")
-            assert SqlalchemyBase.is_valid_uuid4(uuid_string)
+            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 is_valid_uuid4(cls, uuid_string: str) -> bool:
-        try:
-            # Try to create a UUID object from the string
-            uuid_obj = UUID(uuid_string)
-            # Check if the UUID is version 4
-            return uuid_obj.version == 4
-        except ValueError:
-            # Raised if the string is not a valid UUID
-            return False
-
     @classmethod
     def read(
         cls,

letta/orm/user.py

@@ -0,0 +1,25 @@
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.organization import Organization
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.user import User as PydanticUser
+
+
+class User(SqlalchemyBase, OrganizationMixin):
+    """User ORM class"""
+
+    __tablename__ = "user"
+    __pydantic_model__ = PydanticUser
+
+    name: Mapped[str] = mapped_column(nullable=False, doc="The display name of the user.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="users")
+
+    # TODO: Add this back later potentially
+    # agents: Mapped[List["Agent"]] = relationship(
+    #     "Agent", secondary="users_agents", back_populates="users", doc="the agents associated with this user."
+    # )
+    # tokens: Mapped[List["Token"]] = relationship("Token", back_populates="user", doc="the tokens associated with this user.")
+    # jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.")

letta/schemas/user.py

@@ -3,6 +3,7 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.constants import DEFAULT_ORG_ID
 from letta.schemas.letta_base import LettaBase
 
 
@@ -20,14 +21,20 @@ class User(UserBase):
         created_at (datetime): The creation date of the user.
     """
 
-    id: str = UserBase.generate_id_field()
-    org_id: Optional[str] = Field(
-        ..., description="The organization id of the user"
-    )  # TODO: dont make optional, and pass in default org ID
+    id: str = Field(..., description="The id of the user.")
+    organization_id: Optional[str] = Field(DEFAULT_ORG_ID, description="The organization id of the user")
     name: str = Field(..., description="The name of the user.")
     created_at: datetime = Field(default_factory=datetime.utcnow, description="The creation date of the user.")
+    updated_at: datetime = Field(default_factory=datetime.utcnow, description="The update date of the user.")
+    is_deleted: bool = Field(False, description="Whether this user is deleted or not.")
 
 
 class UserCreate(UserBase):
-    name: Optional[str] = Field(None, description="The name of the user.")
-    org_id: Optional[str] = Field(None, description="The organization id of the user.")
+    name: str = Field(..., description="The name of the user.")
+    organization_id: str = Field(..., description="The organization id of the user.")
+
+
+class UserUpdate(UserBase):
+    id: str = Field(..., description="The id of the user to update.")
+    name: Optional[str] = Field(None, description="The new name of the user.")
+    organization_id: Optional[str] = Field(None, description="The new organization id of the user.")

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

@@ -42,7 +42,7 @@ def create_org(
     return org
 
 
-@router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization")
+@router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization_by_id")
 def delete_org(
     org_id: str = Query(..., description="The org_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
@@ -52,7 +52,7 @@ def delete_org(
         org = server.organization_manager.get_organization_by_id(org_id=org_id)
         if org is None:
             raise HTTPException(status_code=404, detail=f"Organization does not exist")
-        server.organization_manager.delete_organization(org_id=org_id)
+        server.organization_manager.delete_organization_by_id(org_id=org_id)
     except HTTPException:
         raise
     except Exception as e:

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

@@ -26,7 +26,7 @@ router = APIRouter(prefix="/users", tags=["users", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[User], operation_id="list_users")
-def get_all_users(
+def list_users(
     cursor: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -35,8 +35,7 @@ def get_all_users(
     Get a list of all users in the database
     """
     try:
-        next_cursor, users = server.ms.get_all_users(cursor=cursor, limit=limit)
-        # processed_users = [{"user_id": user.id} for user in users]
+        next_cursor, users = server.user_manager.list_users(cursor=cursor, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -53,7 +52,7 @@ def create_user(
     Create a new user in the database
     """
 
-    user = server.create_user(request)
+    user = server.user_manager.create_user(request)
     return user
 
 
@@ -64,10 +63,10 @@ def delete_user(
 ):
     # TODO make a soft deletion, instead of a hard deletion
     try:
-        user = server.ms.get_user(user_id=user_id)
+        user = server.user_manager.get_user_by_id(user_id=user_id)
         if user is None:
             raise HTTPException(status_code=404, detail=f"User does not exist")
-        server.ms.delete_user(user_id=user_id)
+        server.user_manager.delete_user_by_id(user_id=user_id)
     except HTTPException:
         raise
     except Exception as e:
@@ -95,7 +94,7 @@ def get_api_keys(
     """
     Get a list of all API keys for a user
     """
-    if server.ms.get_user(user_id=user_id) is None:
+    if server.user_manager.get_user_by_id(user_id=user_id) is None:
         raise HTTPException(status_code=404, detail=f"User does not exist")
     api_keys = server.ms.get_all_api_keys_for_user(user_id=user_id)
     return api_keys

letta/server/server.py

@@ -44,7 +44,6 @@ from letta.log import get_logger
 from letta.memory import get_memory_functions
 from letta.metadata import Base, MetadataStore
 from letta.o1_agent import O1Agent
-from letta.orm.errors import NoResultFound
 from letta.prompts import gpt_system
 from letta.providers import (
     AnthropicProvider,
@@ -87,6 +86,7 @@ from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User, UserCreate
 from letta.services.organization_manager import OrganizationManager
+from letta.services.user_manager import UserManager
 from letta.utils import create_random_username, json_dumps, json_loads
 
 # from letta.llm_api_tools import openai_get_model_list, azure_openai_get_model_list, smart_urljoin
@@ -168,7 +168,7 @@ from sqlalchemy.orm import sessionmaker
 from letta.config import LettaConfig
 
 # NOTE: hack to see if single session management works
-from letta.settings import model_settings, settings
+from letta.settings import model_settings, settings, tool_settings
 
 config = LettaConfig.load()
 
@@ -248,6 +248,7 @@ class SyncServer(Server):
 
         # Managers that interface with data models
         self.organization_manager = OrganizationManager()
+        self.user_manager = UserManager()
 
         # TODO: this should be removed
         # add global default tools (for admin)
@@ -576,7 +577,7 @@ class SyncServer(Server):
         timestamp: Optional[datetime] = None,
     ) -> LettaUsageStatistics:
         """Process an incoming user message and feed it through the Letta agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -625,7 +626,7 @@ class SyncServer(Server):
         timestamp: Optional[datetime] = None,
     ) -> LettaUsageStatistics:
         """Process an incoming system message and feed it through the Letta agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -694,7 +695,7 @@ class SyncServer(Server):
 
         Otherwise, we can pass them in directly.
         """
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -743,7 +744,7 @@ class SyncServer(Server):
     # @LockingServer.agent_lock_decorator
     def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
         """Run a command on the agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -754,19 +755,12 @@ class SyncServer(Server):
                 command = command[1:]  # strip the prefix
         return self._command(user_id=user_id, agent_id=agent_id, command=command)
 
-    def list_users_paginated(self, cursor: str, limit: int) -> List[User]:
-        """List all users"""
-        # TODO: make this paginated
-        next_cursor, users = self.ms.get_all_users(cursor, limit)
-        return next_cursor, users
-
     def create_user(self, request: UserCreate) -> User:
         """Create a new user using a config"""
         if not request.name:
             # auto-generate a name
             request.name = create_random_username()
-        user = User(name=request.name, org_id=request.org_id)
-        self.ms.create_user(user)
+        user = self.user_manager.create_user(request)
         logger.debug(f"Created new user from config: {user}")
 
         # add default for the user
@@ -785,7 +779,7 @@ class SyncServer(Server):
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         """Create a new agent using a config"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
 
         if interface is None:
@@ -809,7 +803,7 @@ class SyncServer(Server):
                 raise ValueError(f"Invalid agent type: {request.agent_type}")
 
         logger.debug(f"Attempting to find user: {user_id}")
-        user = self.ms.get_user(user_id=user_id)
+        user = self.user_manager.get_user_by_id(user_id=user_id)
         if not user:
             raise ValueError(f"cannot find user with associated client id: {user_id}")
 
@@ -834,7 +828,8 @@ class SyncServer(Server):
                     # tool already added
                     continue
                 source_code = parse_source_code(func)
-                json_schema = generate_schema(func, func_name)
+                # memory functions are not terminal
+                json_schema = generate_schema(func, terminal=False, name=func_name)
                 source_type = "python"
                 tags = ["memory", "memgpt-base"]
                 tool = self.create_tool(
@@ -912,7 +907,7 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Update the agents core memory block, return the new state"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=request.id) is None:
             raise ValueError(f"Agent agent_id={request.id} does not exist")
@@ -974,7 +969,7 @@ class SyncServer(Server):
 
     def get_tools_from_agent(self, agent_id: str, user_id: Optional[str]) -> List[Tool]:
         """Get tools from an existing agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -990,7 +985,7 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Add tools from an existing agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1029,7 +1024,7 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Remove tools from an existing agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1075,7 +1070,7 @@ class SyncServer(Server):
         user_id: str,
     ) -> List[AgentState]:
         """List all available agents to a user"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
 
         agents_states = self.ms.list_agents(user_id=user_id)
@@ -1091,7 +1086,7 @@ class SyncServer(Server):
         if user_id is None:
             agents_states = self.ms.list_all_agents()
         else:
-            if self.ms.get_user(user_id=user_id) is None:
+            if self.user_manager.get_user_by_id(user_id=user_id) is None:
                 raise ValueError(f"User user_id={user_id} does not exist")
 
             agents_states = self.ms.list_agents(user_id=user_id)
@@ -1231,13 +1226,13 @@ class SyncServer(Server):
         """Get the agent state"""
         return self.ms.get_agent(agent_id=agent_id, user_id=user_id)
 
-    def get_user(self, user_id: str) -> User:
-        """Get the user"""
-        user = self.ms.get_user(user_id=user_id)
-        if user is None:
-            raise ValueError(f"User with user_id {user_id} does not exist")
-        else:
-            return user
+    # def get_user(self, user_id: str) -> User:
+    #     """Get the user"""
+    #     user = self.user_manager.get_user_by_id(user_id=user_id)
+    #     if user is None:
+    #         raise ValueError(f"User with user_id {user_id} does not exist")
+    #     else:
+    #         return user
 
     def get_agent_memory(self, agent_id: str) -> Memory:
         """Return the memory of an agent (core memory)"""
@@ -1328,7 +1323,7 @@ class SyncServer(Server):
 
     def get_agent_archival(self, user_id: str, agent_id: str, start: int, count: int) -> List[Passage]:
         """Paginated query of all messages in agent archival memory"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1353,7 +1348,7 @@ class SyncServer(Server):
         order_by: Optional[str] = "created_at",
         reverse: Optional[bool] = False,
     ) -> List[Passage]:
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1368,7 +1363,7 @@ class SyncServer(Server):
         return records
 
     def insert_archival_memory(self, user_id: str, agent_id: str, memory_contents: str) -> List[Passage]:
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1383,7 +1378,7 @@ class SyncServer(Server):
         return [letta_agent.persistence_manager.archival_memory.storage.get(id=passage_id) for passage_id in passage_ids]
 
     def delete_archival_memory(self, user_id: str, agent_id: str, memory_id: str):
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1414,7 +1409,7 @@ class SyncServer(Server):
         assistant_message_function_name: str = constants.DEFAULT_MESSAGE_TOOL,
         assistant_message_function_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> Union[List[Message], List[LettaMessage]]:
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1456,7 +1451,7 @@ class SyncServer(Server):
 
     def get_agent_state(self, user_id: str, agent_id: Optional[str], agent_name: Optional[str] = None) -> Optional[AgentState]:
         """Return the config of an agent"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if agent_id:
             if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
@@ -1497,7 +1492,7 @@ class SyncServer(Server):
 
     def update_agent_core_memory(self, user_id: str, agent_id: str, new_memory_contents: dict) -> Memory:
         """Update the agents core memory block, return the new state"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1528,7 +1523,7 @@ class SyncServer(Server):
 
     def rename_agent(self, user_id: str, agent_id: str, new_agent_name: str) -> AgentState:
         """Update the name of the agent in the database"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1550,13 +1545,9 @@ class SyncServer(Server):
         assert isinstance(letta_agent.agent_state.id, str)
         return letta_agent.agent_state
 
-    def delete_user(self, user_id: str):
-        # TODO: delete user
-        pass
-
     def delete_agent(self, user_id: str, agent_id: str):
         """Delete an agent in the database"""
-        if self.ms.get_user(user_id=user_id) is None:
+        if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
@@ -1585,7 +1576,8 @@ class SyncServer(Server):
 
     def api_key_to_user(self, api_key: str) -> str:
         """Decode an API key to a user"""
-        user = self.ms.get_user_from_api_key(api_key=api_key)
+        token = self.ms.get_api_key(api_key=api_key)
+        user = self.user_manager.get_user_by_id(token.user_id)
         if user is None:
             raise HTTPException(status_code=403, detail="Invalid credentials")
         else:
@@ -2018,7 +2010,10 @@ class SyncServer(Server):
     def add_default_external_tools(self, user_id: Optional[str] = None) -> bool:
         """Add default langchain tools. Return true if successful, false otherwise."""
         success = True
-        tools = Tool.load_default_langchain_tools() + Tool.load_default_crewai_tools() + Tool.load_default_composio_tools()
+        if tool_settings.composio_api_key:
+            tools = Tool.load_default_langchain_tools() + Tool.load_default_crewai_tools() + Tool.load_default_composio_tools()
+        else:
+            tools = Tool.load_default_langchain_tools() + Tool.load_default_crewai_tools()
         for tool in tools:
             try:
                 self.ms.create_tool(tool)
@@ -2113,29 +2108,15 @@ class SyncServer(Server):
         letta_agent = self._get_or_load_agent(agent_id=agent_id)
         return letta_agent.retry_message()
 
+    # TODO: Move a lot of this default logic to the ORM
     def get_default_user(self) -> User:
+        self.organization_manager.create_default_organization()
+        user = self.user_manager.create_default_user()
 
-        from letta.constants import DEFAULT_ORG_ID, DEFAULT_USER_ID, DEFAULT_USER_NAME
-
-        # check if default org exists
-        try:
-            self.organization_manager.get_organization_by_id(DEFAULT_ORG_ID)
-        except NoResultFound:
-            self.organization_manager.create_default_organization()
-
-        # check if default user exists
-        try:
-            self.get_user(DEFAULT_USER_ID)
-        except ValueError:
-            user = User(name=DEFAULT_USER_NAME, org_id=DEFAULT_ORG_ID, id=DEFAULT_USER_ID)
-            self.ms.create_user(user)
-
-            # add default data (TODO: move to org)
-            self.add_default_blocks(user.id)
-            self.add_default_tools(module_name="base", user_id=user.id)
+        self.add_default_blocks(user.id)
+        self.add_default_tools(module_name="base", user_id=user.id)
 
-        # check if default org exists
-        return self.get_user(DEFAULT_USER_ID)
+        return user
 
     def get_user_or_default(self, user_id: Optional[str]) -> User:
         """Get the user object for user_id if it exists, otherwise return the default user object"""
@@ -2143,7 +2124,7 @@ class SyncServer(Server):
             return self.get_default_user()
         else:
             try:
-                return self.get_user(user_id=user_id)
+                return self.user_manager.get_user_by_id(user_id=user_id)
             except ValueError:
                 raise HTTPException(status_code=404, detail=f"User with id {user_id} not found")
 

letta/services/organization_manager.py

@@ -1,11 +1,10 @@
 from typing import List, Optional
 
-from sqlalchemy.exc import NoResultFound
-
 from letta.constants import DEFAULT_ORG_ID, DEFAULT_ORG_NAME
+from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization
 from letta.schemas.organization import Organization as PydanticOrganization
-from letta.utils import create_random_username
+from letta.utils import create_random_username, enforce_types
 
 
 class OrganizationManager:
@@ -20,6 +19,7 @@ class OrganizationManager:
 
         self.session_maker = db_context
 
+    @enforce_types
     def get_organization_by_id(self, org_id: str) -> PydanticOrganization:
         """Fetch an organization by ID."""
         with self.session_maker() as session:
@@ -29,6 +29,7 @@ class OrganizationManager:
             except NoResultFound:
                 raise ValueError(f"Organization with id {org_id} not found.")
 
+    @enforce_types
     def create_organization(self, name: Optional[str] = None) -> PydanticOrganization:
         """Create a new organization. If a name is provided, it is used, otherwise, a random one is generated."""
         with self.session_maker() as session:
@@ -36,14 +37,21 @@ class OrganizationManager:
             org.create(session)
             return org.to_pydantic()
 
+    @enforce_types
     def create_default_organization(self) -> PydanticOrganization:
         """Create the default organization."""
         with self.session_maker() as session:
-            org = Organization(name=DEFAULT_ORG_NAME)
-            org.id = DEFAULT_ORG_ID
-            org.create(session)
+            # Try to get it first
+            try:
+                org = Organization.read(db_session=session, identifier=DEFAULT_ORG_ID)
+            # If it doesn't exist, make it
+            except NoResultFound:
+                org = Organization(name=DEFAULT_ORG_NAME, id=DEFAULT_ORG_ID)
+                org.create(session)
+
             return org.to_pydantic()
 
+    @enforce_types
     def update_organization_name_using_id(self, org_id: str, name: Optional[str] = None) -> PydanticOrganization:
         """Update an organization."""
         with self.session_maker() as session:
@@ -53,12 +61,14 @@ class OrganizationManager:
             organization.update(session)
             return organization.to_pydantic()
 
-    def delete_organization(self, org_id: str):
+    @enforce_types
+    def delete_organization_by_id(self, org_id: str):
         """Delete an organization by marking it as deleted."""
         with self.session_maker() as session:
             organization = Organization.read(db_session=session, identifier=org_id)
             organization.delete(session)
 
+    @enforce_types
     def list_organizations(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticOrganization]:
         """List organizations with pagination based on cursor (org_id) and limit."""
         with self.session_maker() as session:

letta/services/user_manager.py

@@ -0,0 +1,99 @@
+from typing import List, Optional, Tuple
+
+from letta.constants import DEFAULT_ORG_ID, DEFAULT_USER_ID, DEFAULT_USER_NAME
+
+# TODO: Remove this once we translate all of these to the ORM
+from letta.metadata import AgentModel, AgentSourceMappingModel, SourceModel
+from letta.orm.errors import NoResultFound
+from letta.orm.organization import Organization as OrganizationModel
+from letta.orm.user import User as UserModel
+from letta.schemas.user import User as PydanticUser
+from letta.schemas.user import UserCreate, UserUpdate
+from letta.utils import enforce_types
+
+
+class UserManager:
+    """Manager class to handle business logic related to Users."""
+
+    def __init__(self):
+        # Fetching the db_context similarly as in OrganizationManager
+        from letta.server.server import db_context
+
+        self.session_maker = db_context
+
+    @enforce_types
+    def create_default_user(self, org_id: str = DEFAULT_ORG_ID) -> PydanticUser:
+        """Create the default user."""
+        with self.session_maker() as session:
+            # Make sure the org id exists
+            try:
+                OrganizationModel.read(db_session=session, identifier=org_id)
+            except NoResultFound:
+                raise ValueError(f"No organization with {org_id} exists in the organization table.")
+
+            # Try to retrieve the user
+            try:
+                user = UserModel.read(db_session=session, identifier=DEFAULT_USER_ID)
+            except NoResultFound:
+                # If it doesn't exist, make it
+                user = UserModel(id=DEFAULT_USER_ID, name=DEFAULT_USER_NAME, organization_id=org_id)
+                user.create(session)
+
+            return user.to_pydantic()
+
+    @enforce_types
+    def create_user(self, user_create: UserCreate) -> PydanticUser:
+        """Create a new user if it doesn't already exist."""
+        with self.session_maker() as session:
+            new_user = UserModel(**user_create.model_dump())
+            new_user.create(session)
+            return new_user.to_pydantic()
+
+    @enforce_types
+    def update_user(self, user_update: UserUpdate) -> PydanticUser:
+        """Update user details."""
+        with self.session_maker() as session:
+            # Retrieve the existing user by ID
+            existing_user = UserModel.read(db_session=session, identifier=user_update.id)
+
+            # Update only the fields that are provided in UserUpdate
+            update_data = user_update.model_dump(exclude_unset=True, exclude_none=True)
+            for key, value in update_data.items():
+                setattr(existing_user, key, value)
+
+            # Commit the updated user
+            existing_user.update(session)
+            return existing_user.to_pydantic()
+
+    @enforce_types
+    def delete_user_by_id(self, user_id: str):
+        """Delete a user and their associated records (agents, sources, mappings)."""
+        with self.session_maker() as session:
+            # Delete from user table
+            user = UserModel.read(db_session=session, identifier=user_id)
+            user.delete(session)
+
+            # TODO: Remove this once we have ORM models for the Agent, Source, and AgentSourceMapping
+            # Cascade delete for related models: Agent, Source, AgentSourceMapping
+            session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()
+            session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()
+            session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()
+
+            session.commit()
+
+    @enforce_types
+    def get_user_by_id(self, user_id: str) -> PydanticUser:
+        """Fetch a user by ID."""
+        with self.session_maker() as session:
+            try:
+                user = UserModel.read(db_session=session, identifier=user_id)
+                return user.to_pydantic()
+            except NoResultFound:
+                raise ValueError(f"User with id {user_id} not found.")
+
+    @enforce_types
+    def list_users(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> Tuple[Optional[str], List[PydanticUser]]:
+        """List users with pagination using cursor (id) and limit."""
+        with self.session_maker() as session:
+            results = UserModel.list(db_session=session, cursor=cursor, limit=limit)
+            return [user.to_pydantic() for user in results]

letta/settings.py

@@ -7,6 +7,10 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 from letta.local_llm.constants import DEFAULT_WRAPPER_NAME
 
 
+class ToolSettings(BaseSettings):
+    composio_api_key: Optional[str] = None
+
+
 class ModelSettings(BaseSettings):
 
     # env_prefix='my_prefix_'
@@ -99,3 +103,4 @@ class TestSettings(Settings):
 settings = Settings(_env_parse_none_str="None")
 test_settings = TestSettings()
 model_settings = ModelSettings()
+tool_settings = ToolSettings()

{letta_nightly-0.5.0.dev20241023104105.dist-info → letta_nightly-0.5.1.dev20241023193051.dist-info}/METADATA

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

{letta_nightly-0.5.0.dev20241023104105.dist-info → letta_nightly-0.5.1.dev20241023193051.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=kRTa2BzRf4EWmx6MkOXUyaisXDj7-6NkmY22gd7h_xs,1014
+letta/__init__.py,sha256=zlZXKr0iQIsC7FTkN9fjTvAgQGPXyr0nnkMJ7_OE1D0,1014
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=PRMDj0vZu5TGj-k2apeWcWYzJnBR36prdMXTKWnRYc8,72997
 letta/agent_store/chroma.py,sha256=upR5zGnGs6I6btulEYbiZdGG87BgKjxUJOQZ4Y-RQ_M,12492
@@ -17,7 +17,7 @@ letta/client/client.py,sha256=CLOdsr3rVfWHQBPG-NN4sHKKn0Cn0VqIcjtHGxYaix4,93462
 letta/client/streaming.py,sha256=bfWlUu7z7EoPfKxBqIarYxGKyrL7Pj79BlliToqcCgI,4592
 letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=j2I90fOh9d9__kOYObwTDLbvVwYR50rIql5nzrvREKg,19161
-letta/constants.py,sha256=Y7MNpkAZfQ1Mo-AhgFiA_dFQLDCiZT6ebCG_n0R_0FQ,6784
+letta/constants.py,sha256=CLC--_fz5Gibaot0rJObjt53o-KO1LfxiAOJuwplHSI,6821
 letta/credentials.py,sha256=D9mlcPsdDWlIIXQQD8wSPE9M_QvsRrb0p3LB5i9OF5Q,5806
 letta/data_sources/connectors.py,sha256=qO81ASB6V-vDPthfHYtZiyqcQDQPTT0NuD8hVwC6xI0,9907
 letta/data_sources/connectors_helper.py,sha256=2TQjCt74fCgT5sw1AP8PalDEk06jPBbhrPG4HVr-WLs,3371
@@ -83,7 +83,7 @@ letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ft
 letta/log.py,sha256=QHquDnL7oUAvdKlAwUlCK9zXKDMUjrU9WA0bxnMsP0Y,2101
 letta/main.py,sha256=yHgM1lltQZvbE8k0QDQMmVyJiWEj07ZTOYIBHDxE_DQ,18709
 letta/memory.py,sha256=6q1x3-PY-PeXzAt6hvP-UF1ajvroPZ7XW-5nLy-JhMo,17657
-letta/metadata.py,sha256=dcQk1dx5ugO73I6bcOMpNapbFtphSiaG_80yL3rIU-U,34811
+letta/metadata.py,sha256=a4XvHD6m52Pu1_Mr0m0yN0mFgo99OLKDtglfRBz6YRs,31548
 letta/o1_agent.py,sha256=0jospImZUKhuQZ0cop0INj8xI6cxhxNffGA8iloHyfU,3114
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
@@ -91,10 +91,11 @@ letta/orm/__all__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/orm/base.py,sha256=9k7mwKDApJNpbrk6oXosQ7amlpeYhDzArdYTZ6BhfpQ,2405
 letta/orm/enums.py,sha256=KfHcFt_fR6GUmSlmfsa-TetvmuRxGESNve8MStRYW64,145
-letta/orm/errors.py,sha256=dYyFwsBuEOS11Wjdz3AAoR4OhejSXNBdQhU71pxymd0,111
-letta/orm/mixins.py,sha256=nOG8Bt4cP75dPPOnI35efFrBZ2OSa6bVRuEFrUuJfBw,1224
-letta/orm/organization.py,sha256=JykIMHJ_g3JVgBaRliBVlqe9iMoahHqSlfwWZv_LDxA,1695
-letta/orm/sqlalchemy_base.py,sha256=YJJBqZ3S6Gp7fr_nBTXBtOt_5rKk-zBBuBUMTAgyRWk,9337
+letta/orm/errors.py,sha256=somsGtotFlb3SDM6tKdZ5TDGwEEP3ppx47ICAvNMnkg,225
+letta/orm/mixins.py,sha256=NtJUSsOv6SM5GY9gXgHdq0smdXEeFv6tWXW_chpW0rw,2157
+letta/orm/organization.py,sha256=afjWs0FU2lOPOHsw_BhDvdmx4f19e1_Jfc0b1w2Bz_8,1316
+letta/orm/sqlalchemy_base.py,sha256=_UBfwpAeuHsPChu6EVV6jHQE_AMPDzE8Loj1a71M2ng,8973
+letta/orm/user.py,sha256=wRo776d-bsKE6ChJkbjO15jHUQ22RiJauhJtXSkOzoc,1079
 letta/persistence_manager.py,sha256=LlLgEDpSafCPAiyKmuq0NvVAnfBkZo6TWbGIKYQjQBs,5200
 letta/personas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/personas/examples/anna_pa.txt,sha256=zgiNdSNhy1HQy58cF_6RFPzcg2i37F9v38YuL1CW40A,1849
@@ -145,7 +146,7 @@ letta/schemas/passage.py,sha256=eYQMxD_XjHAi72jmqcGBU4wM4VZtSU0XK8uhQxxN3Ug,3563
 letta/schemas/source.py,sha256=hB4Ai6Nj8dFdbxv5_Qaf4uN_cmdGmnzgc-4QnHXcV3o,2562
 letta/schemas/tool.py,sha256=m8jWIsPUhekoQcjX7U_Y5vwhhQqSKn748RcXNXRiLGg,10329
 letta/schemas/usage.py,sha256=lvn1ooHwLEdv6gwQpw5PBUbcwn_gwdT6HA-fCiix6sY,817
-letta/schemas/user.py,sha256=D7DiPzieXZIHOLInJdYZlHjKOy2bl7KxGCesNk0yf5E,1003
+letta/schemas/user.py,sha256=s1D9QoyBwxsbcZALXg0cJIfKz-3k47UGJeaheiGxusU,1478
 letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -172,13 +173,13 @@ letta/server/rest_api/routers/v1/blocks.py,sha256=0WekE_yBD2U3jYgPxI0DCFjACWavCA
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=a-j0v-5A0un0pVCOHpfeWnzpOWkVDQO6ti42k_qAlZY,2272
 letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFlJaaO4uL95VY,877
-letta/server/rest_api/routers/v1/organizations.py,sha256=yIni1i1Yurcbu0SwURm01IEEmlTgiWQ7ci6BefNZT_I,2025
+letta/server/rest_api/routers/v1/organizations.py,sha256=3XlHPUc6ZdMOVZNdarwDM8ZxYisoHunSZQ0ozzX5orU,2037
 letta/server/rest_api/routers/v1/sources.py,sha256=eY_pk9jRL2Y9yIZdsTjH6EuKsfH1neaTU15MKNL0dvw,8749
 letta/server/rest_api/routers/v1/tools.py,sha256=vxE4b5juoiBiNWmplktuv6GEgenCkKBRov-t6usUJ9A,3665
-letta/server/rest_api/routers/v1/users.py,sha256=Y2rDvHOG1B5FLSOjutY3R22vt48IngbZ-9h8CohG5rc,3378
+letta/server/rest_api/routers/v1/users.py,sha256=bxQ-YdevjDqmgNDfbSPAG_4KEVvPNBHD_-Lp1MdeMec,3374
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=Fc2ZGKzLaBa2sEtSTVjJ8D5M0xIwsWC0CVAOIJaD3rY,2176
-letta/server/server.py,sha256=TI9VItwqQ0M-zBHQJwdSKlx5aDMDGczK6vOzagy2zeA,91063
+letta/server/server.py,sha256=EBDj5iH2tGr_GsMX6I_yRO6IBYpNpZUZxFY2nGqPDrc,90912
 letta/server/startup.sh,sha256=jeGV7B_PS0hS-tT6o6GpACrUbV9WV1NI2L9aLoUDDtc,311
 letta/server/static_files/assets/index-3ab03d5b.css,sha256=OrA9W4iKJ5h2Wlr7GwdAT4wow0CM8hVit1yOxEL49Qw,54295
 letta/server/static_files/assets/index-d6b3669a.js,sha256=i1nHReU0RPnj-a5W0nNPV4Y9bQ0FOW0ztjMz8a2AE-Y,1821560
@@ -192,14 +193,15 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=M_-gM5iuDBwa1cuN2IGNCG5GxMJwU2d3XW93XALv9s8,1821
 letta/server/ws_api/server.py,sha256=C2Kv48PCwl46DQFb0ZP30s86KJLQ6dZk2AhWQEZn9pY,6004
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/organization_manager.py,sha256=834mNQDVaf6TKx-icAMeOgiYaq1NXtuM7je3SjULlYI,3036
-letta/settings.py,sha256=gNdH-Ty6f-Nfz2j9ZMZFRQHac2KzgsxLZNt5l_TiAyo,3301
+letta/services/organization_manager.py,sha256=skEByzSiLgFesBRbm87VKR-TSUK3LhJitTwN1Zl6-Hw,3379
+letta/services/user_manager.py,sha256=q2GiGGv-bMTob2CT17onk38oHkWqU_DQap0sxQMhmkg,4376
+letta/settings.py,sha256=yiYNmnYKj_BdTm0cBEIvQKYGU-lCmFntqsyVfRUy3_k,3411
 letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,15736
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=SXLEYhyp3gHyIjrxNIKNZZ5ittKo3KOj6zxgC_Trex0,31012
-letta_nightly-0.5.0.dev20241023104105.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.5.0.dev20241023104105.dist-info/METADATA,sha256=n2RNxyAEkgg6neEBHsFKxoUpeu9o4qlPSIdJ3ynWx0M,10660
-letta_nightly-0.5.0.dev20241023104105.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.5.0.dev20241023104105.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.5.0.dev20241023104105.dist-info/RECORD,,
+letta_nightly-0.5.1.dev20241023193051.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.5.1.dev20241023193051.dist-info/METADATA,sha256=2A5lizaE-2kLa_idJ7BxYSzz9PJYEZdkgtvwrFVpF2Q,10660
+letta_nightly-0.5.1.dev20241023193051.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.5.1.dev20241023193051.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.5.1.dev20241023193051.dist-info/RECORD,,