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

letta/server/server.py

@@ -80,12 +80,13 @@ from letta.schemas.memory import (
     RecallMemorySummary,
 )
 from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
-from letta.schemas.organization import Organization, OrganizationCreate
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 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
@@ -167,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()
 
@@ -245,6 +246,10 @@ class SyncServer(Server):
         self.config = config
         self.ms = MetadataStore(self.config)
 
+        # 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)
         self.add_default_tools(module_name="base")
@@ -572,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")
@@ -621,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")
@@ -690,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")
@@ -739,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")
@@ -750,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
@@ -773,20 +771,6 @@ class SyncServer(Server):
 
         return user
 
-    def create_organization(self, request: OrganizationCreate) -> Organization:
-        """Create a new org using a config"""
-        if not request.name:
-            # auto-generate a name
-            request.name = create_random_username()
-        org = Organization(name=request.name)
-        self.ms.create_organization(org)
-        logger.info(f"Created new org from config: {org}")
-
-        # add default for the org
-        # TODO: add default data
-
-        return org
-
     def create_agent(
         self,
         request: CreateAgent,
@@ -795,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:
@@ -819,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}")
 
@@ -844,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(
@@ -922,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")
@@ -984,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")
@@ -1000,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")
@@ -1039,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")
@@ -1085,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)
@@ -1101,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)
@@ -1241,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)"""
@@ -1338,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")
@@ -1363,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")
@@ -1378,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")
@@ -1393,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")
@@ -1424,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")
@@ -1466,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:
@@ -1507,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")
@@ -1538,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")
@@ -1560,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")
@@ -1595,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:
@@ -2028,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)
@@ -2123,34 +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_ORG_NAME,
-            DEFAULT_USER_ID,
-            DEFAULT_USER_NAME,
-        )
-
-        # check if default org exists
-        default_org = self.ms.get_organization(DEFAULT_ORG_ID)
-        if not default_org:
-            org = Organization(name=DEFAULT_ORG_NAME, id=DEFAULT_ORG_ID)
-            self.ms.create_organization(org)
-
-        # 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"""
@@ -2158,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

@@ -0,0 +1,76 @@
+from typing import List, Optional
+
+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, enforce_types
+
+
+class OrganizationManager:
+    """Manager class to handle business logic related to Organizations."""
+
+    def __init__(self):
+        # This is probably horrible but we reuse this technique from metadata.py
+        # TODO: Please refactor this out
+        # I am currently working on a ORM refactor and would like to make a more minimal set of changes
+        # - Matt
+        from letta.server.server import db_context
+
+        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:
+            try:
+                organization = Organization.read(db_session=session, identifier=org_id)
+                return organization.to_pydantic()
+            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:
+            org = Organization(name=name if name else create_random_username())
+            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:
+            # 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:
+            organization = Organization.read(db_session=session, identifier=org_id)
+            if name:
+                organization.name = name
+            organization.update(session)
+            return organization.to_pydantic()
+
+    @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:
+            results = Organization.list(db_session=session, cursor=cursor, limit=limit)
+            return [org.to_pydantic() for org in results]

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.dev20241022104124.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.dev20241022104124
+Version: 0.5.1.dev20241023193051
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -55,6 +55,7 @@ Requires-Dist: prettytable (>=3.9.0,<4.0.0)
 Requires-Dist: pyautogen (==0.2.22) ; extra == "autogen"
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
+Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
 Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "milvus"
 Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev"
 Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev"