letta-nightly 0.5.1.dev20241028104150__py3-none-any.whl → 0.5.1.dev20241030104135__py3-none-any.whl

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

@@ -26,11 +26,13 @@ def delete_tool(
 def get_tool(
     tool_id: str,
     server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Get a tool by ID
     """
-    tool = server.tool_manager.get_tool_by_id(tool_id=tool_id)
+    actor = server.get_user_or_default(user_id=user_id)
+    tool = server.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
     if tool is None:
         # return 404 error
         raise HTTPException(status_code=404, detail=f"Tool with id {tool_id} not found.")
@@ -49,7 +51,7 @@ def get_tool_id(
     actor = server.get_user_or_default(user_id=user_id)
 
     try:
-        tool = server.tool_manager.get_tool_by_name_and_org_id(tool_name=tool_name, organization_id=actor.organization_id)
+        tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
         return tool.id
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
@@ -67,7 +69,7 @@ def list_tools(
     """
     try:
         actor = server.get_user_or_default(user_id=user_id)
-        return server.tool_manager.list_tools_for_org(organization_id=actor.organization_id, cursor=cursor, limit=limit)
+        return server.tool_manager.list_tools(actor=actor, cursor=cursor, limit=limit)
     except Exception as e:
         # Log or print the full exception here for debugging
         print(f"Error occurred: {e}")
@@ -85,13 +87,9 @@ def create_tool(
     """
     # Derive user and org id from actor
     actor = server.get_user_or_default(user_id=user_id)
-    request.organization_id = actor.organization_id
-    request.user_id = actor.id
 
     # Send request to create the tool
-    return server.tool_manager.create_or_update_tool(
-        tool_create=request,
-    )
+    return server.tool_manager.create_or_update_tool(tool_create=request, actor=actor)
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
@@ -104,4 +102,5 @@ def update_tool(
     """
     Update an existing tool
     """
-    return server.tool_manager.update_tool_by_id(tool_id, request)
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.tool_manager.update_tool_by_id(tool_id, actor.id, request)

letta/server/rest_api/utils.py

@@ -1,10 +1,13 @@
+import asyncio
 import json
 import traceback
+import warnings
 from enum import Enum
-from typing import AsyncGenerator, Union
+from typing import AsyncGenerator, Optional, Union
 
 from pydantic import BaseModel
 
+from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.server import SyncServer
 
@@ -24,7 +27,11 @@ def sse_formatter(data: Union[dict, str]) -> str:
     return f"data: {data_str}\n\n"
 
 
-async def sse_async_generator(generator: AsyncGenerator, finish_message=True):
+async def sse_async_generator(
+    generator: AsyncGenerator,
+    usage_task: Optional[asyncio.Task] = None,
+    finish_message=True,
+):
     """
     Wraps a generator for use in Server-Sent Events (SSE), handling errors and ensuring a completion message.
 
@@ -45,6 +52,18 @@ async def sse_async_generator(generator: AsyncGenerator, finish_message=True):
                 chunk = str(chunk)
             yield sse_formatter(chunk)
 
+        # If we have a usage task, wait for it and send its result
+        if usage_task is not None:
+            try:
+                usage = await usage_task
+                # Double-check the type
+                if not isinstance(usage, LettaUsageStatistics):
+                    raise ValueError(f"Expected LettaUsageStatistics, got {type(usage)}")
+                yield sse_formatter({"usage": usage.model_dump()})
+            except Exception as e:
+                warnings.warn(f"Error getting usage data: {e}")
+                yield sse_formatter({"error": "Failed to get usage data"})
+
     except Exception as e:
         print("stream decoder hit error:", e)
         print(traceback.print_stack())

letta/server/server.py

@@ -37,11 +37,13 @@ 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,
     AzureProvider,
     GoogleAIProvider,
+    GroqProvider,
     LettaProvider,
     OllamaProvider,
     OpenAIProvider,
@@ -73,6 +75,7 @@ from letta.schemas.memory import (
     RecallMemorySummary,
 )
 from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
+from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate
@@ -251,12 +254,12 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.add_default_blocks(self.default_user.id)
-            self.tool_manager.add_default_tools(module_name="base", user_id=self.default_user.id, org_id=self.default_org.id)
+            self.tool_manager.add_default_tools(module_name="base", actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future
             if settings.load_default_external_tools:
-                self.add_default_external_tools(user_id=self.default_user.id, org_id=self.default_org.id)
+                self.add_default_external_tools(actor=self.default_user)
 
         # collect providers (always has Letta as a default)
         self._enabled_providers: List[Provider] = [LettaProvider()]
@@ -296,6 +299,8 @@ class SyncServer(Server):
                     api_version=model_settings.azure_api_version,
                 )
             )
+        if model_settings.groq_api_key:
+            self._enabled_providers.append(GroqProvider(api_key=model_settings.groq_api_key))
         if model_settings.vllm_api_base:
             # vLLM exposes both a /chat/completions and a /completions endpoint
             self._enabled_providers.append(
@@ -345,10 +350,10 @@ class SyncServer(Server):
             }
         )
 
-    def _load_agent(self, user_id: str, agent_id: str, interface: Union[AgentInterface, None] = None) -> Agent:
+    def _load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Loads a saved agent into memory (if it doesn't exist, throw an error)"""
-        assert isinstance(user_id, str), user_id
         assert isinstance(agent_id, str), agent_id
+        user_id = actor.id
 
         # If an interface isn't specified, use the default
         if interface is None:
@@ -365,7 +370,7 @@ class SyncServer(Server):
             logger.debug(f"Creating an agent object")
             tool_objs = []
             for name in agent_state.tools:
-                tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=name, user_id=user_id)
+                tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
                 if not tool_obj:
                     logger.exception(f"Tool {name} does not exist for user {user_id}")
                     raise ValueError(f"Tool {name} does not exist for user {user_id}")
@@ -396,13 +401,14 @@ class SyncServer(Server):
         if not agent_state:
             raise ValueError(f"Agent does not exist")
         user_id = agent_state.user_id
+        actor = self.user_manager.get_user_by_id(user_id)
 
         logger.debug(f"Checking for agent user_id={user_id} agent_id={agent_id}")
         # TODO: consider disabling loading cached agents due to potential concurrency issues
         letta_agent = self._get_agent(user_id=user_id, agent_id=agent_id)
         if not letta_agent:
             logger.debug(f"Agent not loaded, loading agent user_id={user_id} agent_id={agent_id}")
-            letta_agent = self._load_agent(user_id=user_id, agent_id=agent_id)
+            letta_agent = self._load_agent(agent_id=agent_id, actor=actor)
         return letta_agent
 
     def _step(
@@ -759,11 +765,12 @@ class SyncServer(Server):
     def create_agent(
         self,
         request: CreateAgent,
-        user_id: str,
+        actor: User,
         # interface
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         """Create a new agent using a config"""
+        user_id = actor.id
         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")
 
@@ -801,7 +808,7 @@ class SyncServer(Server):
             tool_objs = []
             if request.tools:
                 for tool_name in request.tools:
-                    tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=user_id)
+                    tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
                     tool_objs.append(tool_obj)
 
             assert request.memory is not None
@@ -822,9 +829,8 @@ class SyncServer(Server):
                         source_type=source_type,
                         tags=tags,
                         json_schema=json_schema,
-                        user_id=user_id,
-                        organization_id=user.organization_id,
-                    )
+                    ),
+                    actor=actor,
                 )
                 tool_objs.append(tool)
                 if not request.tools:
@@ -887,11 +893,14 @@ class SyncServer(Server):
     def update_agent(
         self,
         request: UpdateAgentState,
-        user_id: str,
+        actor: User,
     ):
         """Update the agents core memory block, return the new state"""
-        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")
+        try:
+            self.user_manager.get_user_by_id(user_id=actor.id)
+        except Exception:
+            raise ValueError(f"User user_id={actor.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")
 
@@ -902,7 +911,7 @@ class SyncServer(Server):
         if request.memory:
             assert isinstance(request.memory, Memory), type(request.memory)
             new_memory_contents = request.memory.to_flat_dict()
-            _ = self.update_agent_core_memory(user_id=user_id, agent_id=request.id, new_memory_contents=new_memory_contents)
+            _ = self.update_agent_core_memory(user_id=actor.id, agent_id=request.id, new_memory_contents=new_memory_contents)
 
         # update the system prompt
         if request.system:
@@ -922,7 +931,7 @@ class SyncServer(Server):
             # (1) get tools + make sure they exist
             tool_objs = []
             for tool_name in request.tools:
-                tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=user_id)
+                tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
                 assert tool_obj, f"Tool {tool_name} does not exist"
                 tool_objs.append(tool_obj)
 
@@ -968,8 +977,11 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Add tools from an existing agent"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
+        try:
+            user = self.user_manager.get_user_by_id(user_id=user_id)
+        except NoResultFound:
             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")
 
@@ -978,12 +990,12 @@ class SyncServer(Server):
 
         # Get all the tool objects from the request
         tool_objs = []
-        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id)
+        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=user)
         assert tool_obj, f"Tool with id={tool_id} does not exist"
         tool_objs.append(tool_obj)
 
         for tool in letta_agent.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id)
+            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=user)
             assert tool_obj, f"Tool with id={tool.id} does not exist"
 
             # If it's not the already added tool
@@ -1007,8 +1019,11 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Remove tools from an existing agent"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
+        try:
+            user = self.user_manager.get_user_by_id(user_id=user_id)
+        except NoResultFound:
             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")
 
@@ -1018,7 +1033,7 @@ class SyncServer(Server):
         # Get all the tool_objs
         tool_objs = []
         for tool in letta_agent.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id)
+            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=user)
             assert tool_obj, f"Tool with id={tool.id} does not exist"
 
             # If it's not the tool we want to remove
@@ -1733,7 +1748,7 @@ class SyncServer(Server):
 
         return sources_with_metadata
 
-    def add_default_external_tools(self, user_id: str, org_id: str) -> bool:
+    def add_default_external_tools(self, actor: User) -> bool:
         """Add default langchain tools. Return true if successful, false otherwise."""
         success = True
         tool_creates = ToolCreate.load_default_langchain_tools() + ToolCreate.load_default_crewai_tools()
@@ -1741,7 +1756,7 @@ class SyncServer(Server):
             tool_creates += ToolCreate.load_default_composio_tools()
         for tool_create in tool_creates:
             try:
-                self.tool_manager.create_or_update_tool(tool_create)
+                self.tool_manager.create_or_update_tool(tool_create, actor=actor)
             except Exception as e:
                 warnings.warn(f"An error occurred while creating tool {tool_create}: {e}")
                 warnings.warn(traceback.format_exc())
@@ -1843,6 +1858,16 @@ class SyncServer(Server):
         except ValueError:
             raise HTTPException(status_code=404, detail=f"User with id {user_id} not found")
 
+    def get_organization_or_default(self, org_id: Optional[str]) -> Organization:
+        """Get the organization object for org_id if it exists, otherwise return the default organization object"""
+        if org_id is None:
+            org_id = self.organization_manager.DEFAULT_ORG_ID
+
+        try:
+            return self.organization_manager.get_organization_by_id(org_id=org_id)
+        except ValueError:
+            raise HTTPException(status_code=404, detail=f"Organization with id {org_id} not found")
+
     def list_llm_models(self) -> List[LLMConfig]:
         """List available models"""
 

letta/server/startup.sh

@@ -2,7 +2,7 @@
 echo "Starting MEMGPT server..."
 if [ "$MEMGPT_ENVIRONMENT" = "DEVELOPMENT" ] ; then
     echo "Starting in development mode!"
-    uvicorn letta.server.rest_api.app:app --reload --reload-dir /letta --host 0.0.0.0 --port 8083
+    uvicorn letta.server.rest_api.app:app --reload --reload-dir /letta --host 0.0.0.0 --port 8283
 else
-    uvicorn letta.server.rest_api.app:app --host 0.0.0.0 --port 8083
+    uvicorn letta.server.rest_api.app:app --host 0.0.0.0 --port 8283
 fi

letta/services/tool_manager.py

@@ -9,9 +9,9 @@ from letta.functions.functions import derive_openai_json_schema, load_function_s
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.tool import Tool as ToolModel
-from letta.orm.user import User as UserModel
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
+from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
 
@@ -25,7 +25,7 @@ class ToolManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_or_update_tool(self, tool_create: ToolCreate) -> PydanticTool:
+    def create_or_update_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Derive json_schema
         derived_json_schema = tool_create.json_schema or derive_openai_json_schema(tool_create)
@@ -34,105 +34,72 @@ class ToolManager:
         try:
             # NOTE: We use the organization id here
             # This is important, because even if it's a different user, adding the same tool to the org should not happen
-            tool = self.get_tool_by_name_and_org_id(tool_name=derived_name, organization_id=tool_create.organization_id)
+            tool = self.get_tool_by_name(tool_name=derived_name, actor=actor)
             # Put to dict and remove fields that should not be reset
-            update_data = tool_create.model_dump(exclude={"user_id", "organization_id", "module", "terminal"}, exclude_unset=True)
+            update_data = tool_create.model_dump(exclude={"module", "terminal"}, exclude_unset=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(tool, key) != value}
 
             # If there's anything to update
             if update_data:
-                self.update_tool_by_id(tool.id, ToolUpdate(**update_data))
+                self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
                 warnings.warn(
-                    f"`create_or_update_tool` was called with user_id={tool_create.user_id}, organization_id={tool_create.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
+                    f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
                 )
         except NoResultFound:
             tool_create.json_schema = derived_json_schema
             tool_create.name = derived_name
-            tool = self.create_tool(tool_create)
+            tool = self.create_tool(tool_create, actor=actor)
 
         return tool
 
     @enforce_types
-    def create_tool(self, tool_create: ToolCreate) -> PydanticTool:
+    def create_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Create the tool
         with self.session_maker() as session:
-            # Include all fields except 'terminal' (which is not part of ToolModel) at the moment
+            # Include all fields except `terminal` (which is not part of ToolModel) at the moment
             create_data = tool_create.model_dump(exclude={"terminal"})
-            tool = ToolModel(**create_data)  # Unpack everything directly into ToolModel
-            tool.create(session)
+            tool = ToolModel(**create_data, organization_id=actor.organization_id)  # Unpack everything directly into ToolModel
+            tool.create(session, actor=actor)
 
         return tool.to_pydantic()
 
     @enforce_types
-    def get_tool_by_id(self, tool_id: str) -> PydanticTool:
+    def get_tool_by_id(self, tool_id: str, actor: PydanticUser) -> PydanticTool:
         """Fetch a tool by its ID."""
         with self.session_maker() as session:
-            try:
-                # Retrieve tool by id using the Tool model's read method
-                tool = ToolModel.read(db_session=session, identifier=tool_id)
-                # Convert the SQLAlchemy Tool object to PydanticTool
-                return tool.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Tool with id {tool_id} not found.")
-
-    @enforce_types
-    def get_tool_by_name_and_user_id(self, tool_name: str, user_id: str) -> PydanticTool:
-        """Retrieve a tool by its name and organization_id."""
-        with self.session_maker() as session:
-            # Use the list method to apply filters
-            results = ToolModel.list(db_session=session, name=tool_name, _user_id=UserModel.get_uid_from_identifier(user_id))
-
-            # Ensure only one result is returned (since there is a unique constraint)
-            if not results:
-                raise NoResultFound(f"Tool with name {tool_name} and user_id {user_id} not found.")
-
-            if len(results) > 1:
-                raise RuntimeError(
-                    f"Multiple tools with name {tool_name} and user_id {user_id} were found. This is a serious error, and means that our table does not have uniqueness constraints properly set up. Please reach out to the letta development team if you see this error."
-                )
-
-            # Return the single result
-            return results[0]
+            # Retrieve tool by id using the Tool model's read method
+            tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
+            # Convert the SQLAlchemy Tool object to PydanticTool
+            return tool.to_pydantic()
 
     @enforce_types
-    def get_tool_by_name_and_org_id(self, tool_name: str, organization_id: str) -> PydanticTool:
-        """Retrieve a tool by its name and organization_id."""
+    def get_tool_by_name(self, tool_name: str, actor: PydanticUser):
+        """Retrieve a tool by its name and a user. We derive the organization from the user, and retrieve that tool."""
         with self.session_maker() as session:
-            # Use the list method to apply filters
-            results = ToolModel.list(
-                db_session=session, name=tool_name, _organization_id=OrganizationModel.get_uid_from_identifier(organization_id)
-            )
-
-            # Ensure only one result is returned (since there is a unique constraint)
-            if not results:
-                raise NoResultFound(f"Tool with name {tool_name} and organization_id {organization_id} not found.")
-
-            if len(results) > 1:
-                raise RuntimeError(
-                    f"Multiple tools with name {tool_name} and organization_id {organization_id} were found. This is a serious error, and means that our table does not have uniqueness constraints properly set up. Please reach out to the letta development team if you see this error."
-                )
-
-            # Return the single result
-            return results[0]
+            tool = ToolModel.read(db_session=session, name=tool_name, actor=actor)
+            return tool.to_pydantic()
 
     @enforce_types
-    def list_tools_for_org(self, organization_id: str, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:
+    def list_tools(self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:
         """List all tools with optional pagination using cursor and limit."""
         with self.session_maker() as session:
             tools = ToolModel.list(
-                db_session=session, cursor=cursor, limit=limit, _organization_id=OrganizationModel.get_uid_from_identifier(organization_id)
+                db_session=session,
+                cursor=cursor,
+                limit=limit,
+                _organization_id=OrganizationModel.get_uid_from_identifier(actor.organization_id),
             )
             return [tool.to_pydantic() for tool in tools]
 
     @enforce_types
-    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate) -> None:
+    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> None:
         """Update a tool by its ID with the given ToolUpdate object."""
         with self.session_maker() as session:
             # Fetch the tool by ID
-            tool = ToolModel.read(db_session=session, identifier=tool_id)
+            tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
 
             # Update tool attributes with only the fields that were explicitly set
             update_data = tool_update.model_dump(exclude_unset=True, exclude_none=True)
@@ -140,20 +107,20 @@ class ToolManager:
                 setattr(tool, key, value)
 
             # Save the updated tool to the database
-            tool.update(db_session=session)
+            tool.update(db_session=session, actor=actor)
 
     @enforce_types
-    def delete_tool_by_id(self, tool_id: str) -> None:
+    def delete_tool_by_id(self, tool_id: str, actor: PydanticUser) -> None:
         """Delete a tool by its ID."""
         with self.session_maker() as session:
             try:
                 tool = ToolModel.read(db_session=session, identifier=tool_id)
-                tool.delete(db_session=session)
+                tool.delete(db_session=session, actor=actor)
             except NoResultFound:
                 raise ValueError(f"Tool with id {tool_id} not found.")
 
     @enforce_types
-    def add_default_tools(self, user_id: str, org_id: str, module_name="base"):
+    def add_default_tools(self, actor: PydanticUser, module_name="base"):
         """Add default tools in {module_name}.py"""
         full_module_name = f"letta.functions.function_sets.{module_name}"
         try:
@@ -187,7 +154,6 @@ class ToolManager:
                     module=schema["module"],
                     source_code=source_code,
                     json_schema=schema["json_schema"],
-                    organization_id=org_id,
-                    user_id=user_id,
                 ),
+                actor=actor,
             )

letta/services/user_manager.py

@@ -85,11 +85,8 @@ class UserManager:
     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.")
+            user = UserModel.read(db_session=session, identifier=user_id)
+            return user.to_pydantic()
 
     @enforce_types
     def get_default_user(self) -> PydanticUser:

{letta_nightly-0.5.1.dev20241028104150.dist-info → letta_nightly-0.5.1.dev20241030104135.dist-info}/METADATA

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