letta-nightly 0.7.16.dev20250515205957__py3-none-any.whl → 0.7.17.dev20250516090339__py3-none-any.whl

letta/__init__.py

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

letta/agents/letta_agent.py

@@ -8,10 +8,11 @@ from openai.types import CompletionUsage
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 
 from letta.agents.base_agent import BaseAgent
-from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages
+from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages_async
 from letta.helpers import ToolRulesSolver
 from letta.helpers.tool_execution_helper import enable_strict_mode
 from letta.interfaces.anthropic_streaming_interface import AnthropicStreamingInterface
+from letta.interfaces.openai_streaming_interface import OpenAIStreamingInterface
 from letta.llm_api.llm_client import LLMClient
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
@@ -61,12 +62,8 @@ class LettaAgent(BaseAgent):
         self.last_function_response = None
 
         # Cached archival memory/message size
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_id)
-
-        # Cached archival memory/message size
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_id)
+        self.num_messages = 0
+        self.num_archival_memories = 0
 
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True) -> LettaResponse:
@@ -81,7 +78,7 @@ class LettaAgent(BaseAgent):
     async def _step(
         self, agent_state: AgentState, input_messages: List[MessageCreate], max_steps: int = 10
     ) -> Tuple[List[Message], List[Message], CompletionUsage]:
-        current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
@@ -129,14 +126,14 @@ class LettaAgent(BaseAgent):
 
     @trace_method
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True
+        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True, stream_tokens: bool = False
     ) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
         agent_state = await self.agent_manager.get_agent_by_id_async(self.agent_id, actor=self.actor)
-        current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
@@ -157,9 +154,16 @@ class LettaAgent(BaseAgent):
             )
             # TODO: THIS IS INCREDIBLY UGLY
             # TODO: THERE ARE MULTIPLE COPIES OF THE LLM_CONFIG EVERYWHERE THAT ARE GETTING MANIPULATED
-            interface = AnthropicStreamingInterface(
-                use_assistant_message=use_assistant_message, put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs
-            )
+            if agent_state.llm_config.model_endpoint_type == "anthropic":
+                interface = AnthropicStreamingInterface(
+                    use_assistant_message=use_assistant_message,
+                    put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs,
+                )
+            elif agent_state.llm_config.model_endpoint_type == "openai":
+                interface = OpenAIStreamingInterface(
+                    use_assistant_message=use_assistant_message,
+                    put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs,
+                )
             async for chunk in interface.process(stream):
                 yield f"data: {chunk.model_dump_json()}\n\n"
 
@@ -197,8 +201,8 @@ class LettaAgent(BaseAgent):
 
         # TODO: This may be out of sync, if in between steps users add files
         # NOTE (cliandy): temporary for now for particlar use cases.
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+        self.num_messages = await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+        self.num_archival_memories = await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
 
         # TODO: Also yield out a letta usage stats SSE
         yield f"data: {usage.model_dump_json()}\n\n"
@@ -215,6 +219,10 @@ class LettaAgent(BaseAgent):
         stream: bool,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
         if settings.experimental_enable_async_db_engine:
+            self.num_messages = self.num_messages or (await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id))
+            self.num_archival_memories = self.num_archival_memories or (
+                await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+            )
             in_context_messages = await self._rebuild_memory_async(
                 in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
             )

letta/interfaces/openai_streaming_interface.py

@@ -0,0 +1,303 @@
+from datetime import datetime, timezone
+from typing import AsyncGenerator, List, Optional
+
+from openai import AsyncStream
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, ToolCallDelta, ToolCallMessage
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
+from letta.server.rest_api.json_parser import OptimisticJSONParser
+from letta.streaming_utils import JSONInnerThoughtsExtractor
+
+
+class OpenAIStreamingInterface:
+    """
+    Encapsulates the logic for streaming responses from OpenAI.
+    This class handles parsing of partial tokens, pre-execution messages,
+    and detection of tool call events.
+    """
+
+    def __init__(self, use_assistant_message: bool = False, put_inner_thoughts_in_kwarg: bool = False):
+        self.use_assistant_message = use_assistant_message
+        self.assistant_message_tool_name = DEFAULT_MESSAGE_TOOL
+        self.assistant_message_tool_kwarg = DEFAULT_MESSAGE_TOOL_KWARG
+
+        self.optimistic_json_parser: OptimisticJSONParser = OptimisticJSONParser()
+        self.function_args_reader = JSONInnerThoughtsExtractor(wait_for_first_key=True)  # TODO: pass in kward
+        self.function_name_buffer = None
+        self.function_args_buffer = None
+        self.function_id_buffer = None
+        self.last_flushed_function_name = None
+
+        # Buffer to hold function arguments until inner thoughts are complete
+        self.current_function_arguments = ""
+        self.current_json_parse_result = {}
+
+        # Premake IDs for database writes
+        self.letta_assistant_message_id = Message.generate_id()
+        self.letta_tool_message_id = Message.generate_id()
+
+        # token counters
+        self.input_tokens = 0
+        self.output_tokens = 0
+
+        self.content_buffer: List[str] = []
+        self.tool_call_name: Optional[str] = None
+        self.tool_call_id: Optional[str] = None
+        self.reasoning_messages = []
+
+    def get_reasoning_content(self) -> List[TextContent]:
+        content = "".join(self.reasoning_messages)
+        return [TextContent(text=content)]
+
+    def get_tool_call_object(self) -> ToolCall:
+        """Useful for agent loop"""
+        return ToolCall(
+            id=self.letta_tool_message_id,
+            function=FunctionCall(arguments=self.current_function_arguments, name=self.last_flushed_function_name),
+        )
+
+    async def process(self, stream: AsyncStream[ChatCompletionChunk]) -> AsyncGenerator[LettaMessage, None]:
+        """
+        Iterates over the OpenAI stream, yielding SSE events.
+        It also collects tokens and detects if a tool call is triggered.
+        """
+        async with stream:
+            prev_message_type = None
+            message_index = 0
+            async for chunk in stream:
+                # track usage
+                if chunk.usage:
+                    self.input_tokens += len(chunk.usage.prompt_tokens)
+                    self.output_tokens += len(chunk.usage.completion_tokens)
+
+                if chunk.choices:
+                    choice = chunk.choices[0]
+                    message_delta = choice.delta
+
+                    if message_delta.tool_calls is not None and len(message_delta.tool_calls) > 0:
+                        tool_call = message_delta.tool_calls[0]
+
+                        if tool_call.function.name:
+                            # If we're waiting for the first key, then we should hold back the name
+                            # ie add it to a buffer instead of returning it as a chunk
+                            if self.function_name_buffer is None:
+                                self.function_name_buffer = tool_call.function.name
+                            else:
+                                self.function_name_buffer += tool_call.function.name
+
+                        if tool_call.id:
+                            # Buffer until next time
+                            if self.function_id_buffer is None:
+                                self.function_id_buffer = tool_call.id
+                            else:
+                                self.function_id_buffer += tool_call.id
+
+                        if tool_call.function.arguments:
+                            # updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(tool_call.function.arguments)
+                            self.current_function_arguments += tool_call.function.arguments
+                            updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(
+                                tool_call.function.arguments
+                            )
+
+                            # If we have inner thoughts, we should output them as a chunk
+                            if updates_inner_thoughts:
+                                if prev_message_type and prev_message_type != "reasoning_message":
+                                    message_index += 1
+                                self.reasoning_messages.append(updates_inner_thoughts)
+                                reasoning_message = ReasoningMessage(
+                                    id=self.letta_tool_message_id,
+                                    date=datetime.now(timezone.utc),
+                                    reasoning=updates_inner_thoughts,
+                                    # name=name,
+                                    otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                )
+                                prev_message_type = reasoning_message.message_type
+                                yield reasoning_message
+
+                                # Additionally inner thoughts may stream back with a chunk of main JSON
+                                # In that case, since we can only return a chunk at a time, we should buffer it
+                                if updates_main_json:
+                                    if self.function_args_buffer is None:
+                                        self.function_args_buffer = updates_main_json
+                                    else:
+                                        self.function_args_buffer += updates_main_json
+
+                            # If we have main_json, we should output a ToolCallMessage
+                            elif updates_main_json:
+
+                                # If there's something in the function_name buffer, we should release it first
+                                # NOTE: we could output it as part of a chunk that has both name and args,
+                                #       however the frontend may expect name first, then args, so to be
+                                #       safe we'll output name first in a separate chunk
+                                if self.function_name_buffer:
+
+                                    # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                                    if self.use_assistant_message and self.function_name_buffer == self.assistant_message_tool_name:
+
+                                        # Store the ID of the tool call so allow skipping the corresponding response
+                                        if self.function_id_buffer:
+                                            self.prev_assistant_message_id = self.function_id_buffer
+
+                                    else:
+                                        if prev_message_type and prev_message_type != "tool_call_message":
+                                            message_index += 1
+                                        self.tool_call_name = str(self.function_name_buffer)
+                                        tool_call_msg = ToolCallMessage(
+                                            id=self.letta_tool_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=self.function_name_buffer,
+                                                arguments=None,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                        )
+                                        prev_message_type = tool_call_msg.message_type
+                                        yield tool_call_msg
+
+                                    # Record what the last function name we flushed was
+                                    self.last_flushed_function_name = self.function_name_buffer
+                                    # Clear the buffer
+                                    self.function_name_buffer = None
+                                    self.function_id_buffer = None
+                                    # Since we're clearing the name buffer, we should store
+                                    # any updates to the arguments inside a separate buffer
+
+                                    # Add any main_json updates to the arguments buffer
+                                    if self.function_args_buffer is None:
+                                        self.function_args_buffer = updates_main_json
+                                    else:
+                                        self.function_args_buffer += updates_main_json
+
+                                # If there was nothing in the name buffer, we can proceed to
+                                # output the arguments chunk as a ToolCallMessage
+                                else:
+
+                                    # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                                    if self.use_assistant_message and (
+                                        self.last_flushed_function_name is not None
+                                        and self.last_flushed_function_name == self.assistant_message_tool_name
+                                    ):
+                                        # do an additional parse on the updates_main_json
+                                        if self.function_args_buffer:
+                                            updates_main_json = self.function_args_buffer + updates_main_json
+                                            self.function_args_buffer = None
+
+                                            # Pretty gross hardcoding that assumes that if we're toggling into the keywords, we have the full prefix
+                                            match_str = '{"' + self.assistant_message_tool_kwarg + '":"'
+                                            if updates_main_json == match_str:
+                                                updates_main_json = None
+
+                                        else:
+                                            # Some hardcoding to strip off the trailing "}"
+                                            if updates_main_json in ["}", '"}']:
+                                                updates_main_json = None
+                                            if updates_main_json and len(updates_main_json) > 0 and updates_main_json[-1:] == '"':
+                                                updates_main_json = updates_main_json[:-1]
+
+                                        if not updates_main_json:
+                                            # early exit to turn into content mode
+                                            continue
+
+                                        # There may be a buffer from a previous chunk, for example
+                                        # if the previous chunk had arguments but we needed to flush name
+                                        if self.function_args_buffer:
+                                            # In this case, we should release the buffer + new data at once
+                                            combined_chunk = self.function_args_buffer + updates_main_json
+
+                                            if prev_message_type and prev_message_type != "assistant_message":
+                                                message_index += 1
+                                            assistant_message = AssistantMessage(
+                                                id=self.letta_assistant_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                content=combined_chunk,
+                                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                            )
+                                            prev_message_type = assistant_message.message_type
+                                            yield assistant_message
+                                            # Store the ID of the tool call so allow skipping the corresponding response
+                                            if self.function_id_buffer:
+                                                self.prev_assistant_message_id = self.function_id_buffer
+                                            # clear buffer
+                                            self.function_args_buffer = None
+                                            self.function_id_buffer = None
+
+                                        else:
+                                            # If there's no buffer to clear, just output a new chunk with new data
+                                            # TODO: THIS IS HORRIBLE
+                                            # TODO: WE USE THE OLD JSON PARSER EARLIER (WHICH DOES NOTHING) AND NOW THE NEW JSON PARSER
+                                            # TODO: THIS IS TOTALLY WRONG AND BAD, BUT SAVING FOR A LARGER REWRITE IN THE NEAR FUTURE
+                                            parsed_args = self.optimistic_json_parser.parse(self.current_function_arguments)
+
+                                            if parsed_args.get(self.assistant_message_tool_kwarg) and parsed_args.get(
+                                                self.assistant_message_tool_kwarg
+                                            ) != self.current_json_parse_result.get(self.assistant_message_tool_kwarg):
+                                                new_content = parsed_args.get(self.assistant_message_tool_kwarg)
+                                                prev_content = self.current_json_parse_result.get(self.assistant_message_tool_kwarg, "")
+                                                # TODO: Assumes consistent state and that prev_content is subset of new_content
+                                                diff = new_content.replace(prev_content, "", 1)
+                                                self.current_json_parse_result = parsed_args
+                                                if prev_message_type and prev_message_type != "assistant_message":
+                                                    message_index += 1
+                                                assistant_message = AssistantMessage(
+                                                    id=self.letta_assistant_message_id,
+                                                    date=datetime.now(timezone.utc),
+                                                    content=diff,
+                                                    # name=name,
+                                                    otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                                )
+                                                prev_message_type = assistant_message.message_type
+                                                yield assistant_message
+
+                                            # Store the ID of the tool call so allow skipping the corresponding response
+                                            if self.function_id_buffer:
+                                                self.prev_assistant_message_id = self.function_id_buffer
+                                            # clear buffers
+                                            self.function_id_buffer = None
+                                    else:
+
+                                        # There may be a buffer from a previous chunk, for example
+                                        # if the previous chunk had arguments but we needed to flush name
+                                        if self.function_args_buffer:
+                                            # In this case, we should release the buffer + new data at once
+                                            combined_chunk = self.function_args_buffer + updates_main_json
+                                            if prev_message_type and prev_message_type != "tool_call_message":
+                                                message_index += 1
+                                            tool_call_msg = ToolCallMessage(
+                                                id=self.letta_tool_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                tool_call=ToolCallDelta(
+                                                    name=None,
+                                                    arguments=combined_chunk,
+                                                    tool_call_id=self.function_id_buffer,
+                                                ),
+                                                # name=name,
+                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                            )
+                                            prev_message_type = tool_call_msg.message_type
+                                            yield tool_call_msg
+                                            # clear buffer
+                                            self.function_args_buffer = None
+                                            self.function_id_buffer = None
+                                        else:
+                                            # If there's no buffer to clear, just output a new chunk with new data
+                                            if prev_message_type and prev_message_type != "tool_call_message":
+                                                message_index += 1
+                                            tool_call_msg = ToolCallMessage(
+                                                id=self.letta_tool_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                tool_call=ToolCallDelta(
+                                                    name=None,
+                                                    arguments=updates_main_json,
+                                                    tool_call_id=self.function_id_buffer,
+                                                ),
+                                                # name=name,
+                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                            )
+                                            prev_message_type = tool_call_msg.message_type
+                                            yield tool_call_msg
+                                            self.function_id_buffer = None

letta/orm/sqlalchemy_base.py

@@ -745,6 +745,17 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         self.is_deleted = True
         return self.update(db_session)
 
+    @handle_db_timeout
+    async def delete_async(self, db_session: "AsyncSession", actor: Optional["User"] = None) -> "SqlalchemyBase":
+        """Soft delete a record asynchronously (mark as deleted)."""
+        logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor} (async)")
+
+        if actor:
+            self._set_created_and_updated_by_fields(actor.id)
+
+        self.is_deleted = True
+        return await self.update_async(db_session)
+
     @handle_db_timeout
     def hard_delete(self, db_session: "Session", actor: Optional["User"] = None) -> None:
         """Permanently removes the record from the database."""
@@ -761,6 +772,20 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             else:
                 logger.debug(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
 
+    @handle_db_timeout
+    async def hard_delete_async(self, db_session: "AsyncSession", actor: Optional["User"] = None) -> None:
+        """Permanently removes the record from the database asynchronously."""
+        logger.debug(f"Hard deleting {self.__class__.__name__} with ID: {self.id} with actor={actor} (async)")
+
+        async with db_session as session:
+            try:
+                await session.delete(self)
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                logger.exception(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}")
+                raise ValueError(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}: {e}")
+
     @handle_db_timeout
     def update(self, db_session: Session, actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":
         logger.debug(...)
@@ -793,6 +818,39 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         await db_session.refresh(self)
         return self
 
+    @classmethod
+    def _size_preprocess(
+        cls,
+        *,
+        db_session: "Session",
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        **kwargs,
+    ):
+        logger.debug(f"Calculating size for {cls.__name__} with filters {kwargs}")
+        query = select(func.count()).select_from(cls)
+
+        if actor:
+            query = cls.apply_access_predicate(query, actor, access, access_type)
+
+        # Apply filtering logic based on kwargs
+        for key, value in kwargs.items():
+            if value:
+                column = getattr(cls, key, None)
+                if not column:
+                    raise AttributeError(f"{cls.__name__} has no attribute '{key}'")
+                if isinstance(value, (list, tuple, set)):  # Check for iterables
+                    query = query.where(column.in_(value))
+                else:  # Single value for equality filtering
+                    query = query.where(column == value)
+
+        # Handle soft deletes if the class has the 'is_deleted' attribute
+        if hasattr(cls, "is_deleted"):
+            query = query.where(cls.is_deleted == False)
+
+        return query
+
     @classmethod
     @handle_db_timeout
     def size(
@@ -817,28 +875,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         Raises:
             DBAPIError: If a database error occurs
         """
-        logger.debug(f"Calculating size for {cls.__name__} with filters {kwargs}")
-
         with db_session as session:
-            query = select(func.count()).select_from(cls)
-
-            if actor:
-                query = cls.apply_access_predicate(query, actor, access, access_type)
-
-            # Apply filtering logic based on kwargs
-            for key, value in kwargs.items():
-                if value:
-                    column = getattr(cls, key, None)
-                    if not column:
-                        raise AttributeError(f"{cls.__name__} has no attribute '{key}'")
-                    if isinstance(value, (list, tuple, set)):  # Check for iterables
-                        query = query.where(column.in_(value))
-                    else:  # Single value for equality filtering
-                        query = query.where(column == value)
-
-            # Handle soft deletes if the class has the 'is_deleted' attribute
-            if hasattr(cls, "is_deleted"):
-                query = query.where(cls.is_deleted == False)
+            query = cls._size_preprocess(db_session=session, actor=actor, access=access, access_type=access_type, **kwargs)
 
             try:
                 count = session.execute(query).scalar()
@@ -847,6 +885,37 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 logger.exception(f"Failed to calculate size for {cls.__name__}")
                 raise e
 
+    @classmethod
+    @handle_db_timeout
+    async def size_async(
+        cls,
+        *,
+        db_session: "AsyncSession",
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        **kwargs,
+    ) -> int:
+        """
+        Get the count of rows that match the provided filters.
+        Args:
+            db_session: SQLAlchemy session
+            **kwargs: Filters to apply to the query (e.g., column_name=value)
+        Returns:
+            int: The count of rows that match the filters
+        Raises:
+            DBAPIError: If a database error occurs
+        """
+        async with db_session as session:
+            query = cls._size_preprocess(db_session=session, actor=actor, access=access, access_type=access_type, **kwargs)
+
+            try:
+                count = await session.execute(query).scalar()
+                return count if count else 0
+            except DBAPIError as e:
+                logger.exception(f"Failed to calculate size for {cls.__name__}")
+                raise e
+
     @classmethod
     def apply_access_predicate(
         cls,

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

@@ -83,7 +83,7 @@ async def list_agents(
     """
 
     # Retrieve the actor (user) details
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # Call list_agents directly without unnecessary dict handling
     return await server.agent_manager.list_agents_async(
@@ -163,7 +163,7 @@ async def import_agent_serialized(
     """
     Import a serialized agent file and recreate the agent in the system.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         serialized_data = await file.read()
@@ -233,7 +233,7 @@ async def create_agent(
     Create a new agent with the specified configuration.
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         return await server.create_agent_async(agent, actor=actor)
     except Exception as e:
         traceback.print_exc()
@@ -248,7 +248,7 @@ async def modify_agent(
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Update an existing agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.update_agent_async(agent_id=agent_id, request=update_agent, actor=actor)
 
 
@@ -333,7 +333,7 @@ def detach_source(
 
 
 @router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
-def retrieve_agent(
+async def retrieve_agent(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -344,7 +344,7 @@ def retrieve_agent(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
-        return server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+        return await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -414,7 +414,7 @@ def retrieve_block(
 
 
 @router.get("/{agent_id}/core-memory/blocks", response_model=List[Block], operation_id="list_core_memory_blocks")
-def list_blocks(
+async def list_blocks(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -424,7 +424,7 @@ def list_blocks(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     try:
-        agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
         return agent.memory.blocks
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -628,9 +628,9 @@ async def send_message(
     Process a user message and return the agent's response.
     This endpoint accepts a message from a user and processes it through the agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
@@ -686,13 +686,13 @@ async def send_message_streaming(
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
     request_start_timestamp_ns = get_utc_timestamp_ns()
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
-    model_compatible = agent.llm_config.model_endpoint_type == "anthropic"
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
 
     if agent_eligible and feature_enabled and model_compatible and request.stream_tokens:
         experimental_agent = LettaAgent(
@@ -705,7 +705,9 @@ async def send_message_streaming(
         )
 
         result = StreamingResponse(
-            experimental_agent.step_stream(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message),
+            experimental_agent.step_stream(
+                request.messages, max_steps=10, use_assistant_message=request.use_assistant_message, stream_tokens=request.stream_tokens
+            ),
             media_type="text/event-stream",
         )
     else:
@@ -784,7 +786,7 @@ async def send_message_async(
     Asynchronously process a user message and return a run object.
     The actual processing happens in the background, and the status can be checked using the run ID.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # Create a new job
     run = Run(
@@ -838,6 +840,6 @@ async def list_agent_groups(
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Lists the groups for an agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     print("in list agents with manager_type", manager_type)
     return server.agent_manager.list_groups(agent_id=agent_id, manager_type=manager_type, actor=actor)

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

@@ -26,7 +26,7 @@ async def list_blocks(
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.block_manager.get_blocks_async(
         actor=actor,
         label=label,

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

@@ -135,7 +135,7 @@ async def send_group_message(
     Process a user message and return the group's response.
     This endpoint accepts a message from a user and processes it through through agents in the group based on the specified pattern
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,
@@ -174,7 +174,7 @@ async def send_group_message_streaming(
     This endpoint accepts a message from a user and processes it through agents in the group based on the specified pattern.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,

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

@@ -52,7 +52,7 @@ async def create_messages_batch(
             detail=f"Server misconfiguration: LETTA_ENABLE_BATCH_JOB_POLLING is set to False.",
         )
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     batch_job = BatchJob(
         user_id=actor.id,
         status=JobStatus.running,
@@ -100,7 +100,7 @@ async def retrieve_batch_run(
     """
     Get the status of a batch run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
@@ -118,7 +118,7 @@ async def list_batch_runs(
     List all batch runs.
     """
     # TODO: filter
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     jobs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.BATCH)
     return [BatchJob.from_job(job) for job in jobs]
@@ -150,7 +150,7 @@ async def list_batch_messages(
     - For subsequent pages, use the ID of the last message from the previous response as the cursor
     - Results will include messages before/after the cursor based on sort_descending
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # First, verify the batch job exists and the user has access to it
     try:
@@ -177,7 +177,7 @@ async def cancel_batch_run(
     """
     Cancel a batch run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)

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

@@ -115,7 +115,7 @@ async def list_run_messages(
     if order not in ["asc", "desc"]:
         raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         messages = server.job_manager.get_run_messages(
@@ -182,7 +182,7 @@ async def list_run_steps(
     if order not in ["asc", "desc"]:
         raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         steps = server.job_manager.get_job_steps(

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

@@ -87,7 +87,7 @@ async def list_tools(
     Get a list of all tools available to agents belonging to the org of the user
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         if name is not None:
             tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)
             return [tool] if tool else []

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

@@ -14,7 +14,7 @@ router = APIRouter(prefix="/users", tags=["users", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[User], operation_id="list_users")
-def list_users(
+async def list_users(
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -23,7 +23,7 @@ def list_users(
     Get a list of all users in the database
     """
     try:
-        users = server.user_manager.list_users(after=after, limit=limit)
+        users = await server.user_manager.list_actors_async(after=after, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -32,7 +32,7 @@ def list_users(
 
 
 @router.post("/", tags=["admin"], response_model=User, operation_id="create_user")
-def create_user(
+async def create_user(
     request: UserCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
@@ -40,33 +40,33 @@ def create_user(
     Create a new user in the database
     """
     user = User(**request.model_dump())
-    user = server.user_manager.create_user(user)
+    user = await server.user_manager.create_actor_async(user)
     return user
 
 
 @router.put("/", tags=["admin"], response_model=User, operation_id="update_user")
-def update_user(
+async def update_user(
     user: UserUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Update a user in the database
     """
-    user = server.user_manager.update_user(user)
+    user = await server.user_manager.update_actor_async(user)
     return user
 
 
 @router.delete("/", tags=["admin"], response_model=User, operation_id="delete_user")
-def delete_user(
+async def delete_user(
     user_id: str = Query(..., description="The user_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     # TODO make a soft deletion, instead of a hard deletion
     try:
-        user = server.user_manager.get_user_by_id(user_id=user_id)
+        user = await server.user_manager.get_actor_by_id_async(actor_id=user_id)
         if user is None:
             raise HTTPException(status_code=404, detail=f"User does not exist")
-        server.user_manager.delete_user_by_id(user_id=user_id)
+        await server.user_manager.delete_actor_by_id_async(user_id=user_id)
     except HTTPException:
         raise
     except Exception as e:

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

@@ -36,7 +36,7 @@ async def create_voice_chat_completions(
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=user_id)
 
     # Create OpenAI async client
     client = openai.AsyncClient(

letta/services/agent_manager.py

@@ -1,3 +1,4 @@
+import asyncio
 from datetime import datetime, timezone
 from typing import Dict, List, Optional, Set, Tuple
 
@@ -905,12 +906,7 @@ class AgentManager:
 
             result = await session.execute(query)
             agents = result.scalars().all()
-            pydantic_agents = []
-            for agent in agents:
-                pydantic_agent = await agent.to_pydantic_async(include_relationships=include_relationships)
-                pydantic_agents.append(pydantic_agent)
-
-            return pydantic_agents
+            return await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents])
 
     @enforce_types
     def list_agents_matching_tags(
@@ -1195,8 +1191,8 @@ class AgentManager:
 
     @enforce_types
     async def get_in_context_messages_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticMessage]:
-        message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
-        return await self.message_manager.get_messages_by_ids_async(message_ids=message_ids, actor=actor)
+        agent = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+        return await self.message_manager.get_messages_by_ids_async(message_ids=agent.message_ids, actor=actor)
 
     @enforce_types
     def get_system_message(self, agent_id: str, actor: PydanticUser) -> PydanticMessage:

letta/services/message_manager.py

@@ -286,6 +286,21 @@ class MessageManager:
         with db_registry.session() as session:
             return MessageModel.size(db_session=session, actor=actor, role=role, agent_id=agent_id)
 
+    @enforce_types
+    async def size_async(
+        self,
+        actor: PydanticUser,
+        role: Optional[MessageRole] = None,
+        agent_id: Optional[str] = None,
+    ) -> int:
+        """Get the total count of messages with optional filters.
+        Args:
+            actor: The user requesting the count
+            role: The role of the message
+        """
+        async with db_registry.async_session() as session:
+            return await MessageModel.size_async(db_session=session, actor=actor, role=role, agent_id=agent_id)
+
     @enforce_types
     def list_user_messages_for_agent(
         self,

letta/services/passage_manager.py

@@ -216,6 +216,20 @@ class PassageManager:
         with db_registry.session() as session:
             return AgentPassage.size(db_session=session, actor=actor, agent_id=agent_id)
 
+    @enforce_types
+    async def size_async(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+    ) -> int:
+        """Get the total count of messages with optional filters.
+        Args:
+            actor: The user requesting the count
+            agent_id: The agent ID of the messages
+        """
+        async with db_registry.async_session() as session:
+            return await AgentPassage.size_async(db_session=session, actor=actor, agent_id=agent_id)
+
     def estimate_embeddings_size(
         self,
         actor: PydanticUser,

letta/services/user_manager.py

@@ -44,6 +44,14 @@ class UserManager:
             new_user.create(session)
             return new_user.to_pydantic()
 
+    @enforce_types
+    async def create_actor_async(self, pydantic_user: PydanticUser) -> PydanticUser:
+        """Create a new user if it doesn't already exist (async version)."""
+        async with db_registry.async_session() as session:
+            new_user = UserModel(**pydantic_user.model_dump(to_orm=True))
+            await new_user.create_async(session)
+            return new_user.to_pydantic()
+
     @enforce_types
     def update_user(self, user_update: UserUpdate) -> PydanticUser:
         """Update user details."""
@@ -60,6 +68,22 @@ class UserManager:
             existing_user.update(session)
             return existing_user.to_pydantic()
 
+    @enforce_types
+    async def update_actor_async(self, user_update: UserUpdate) -> PydanticUser:
+        """Update user details (async version)."""
+        async with db_registry.async_session() as session:
+            # Retrieve the existing user by ID
+            existing_user = await UserModel.read_async(db_session=session, identifier=user_update.id)
+
+            # Update only the fields that are provided in UserUpdate
+            update_data = user_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
+            for key, value in update_data.items():
+                setattr(existing_user, key, value)
+
+            # Commit the updated user
+            await existing_user.update_async(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)."""
@@ -70,6 +94,14 @@ class UserManager:
 
             session.commit()
 
+    @enforce_types
+    async def delete_actor_by_id_async(self, user_id: str):
+        """Delete a user and their associated records (agents, sources, mappings) asynchronously."""
+        async with db_registry.async_session() as session:
+            # Delete from user table
+            user = await UserModel.read_async(db_session=session, identifier=user_id)
+            await user.hard_delete_async(session)
+
     @enforce_types
     def get_user_by_id(self, user_id: str) -> PydanticUser:
         """Fetch a user by ID."""
@@ -77,6 +109,13 @@ class UserManager:
             user = UserModel.read(db_session=session, identifier=user_id)
             return user.to_pydantic()
 
+    @enforce_types
+    async def get_actor_by_id_async(self, actor_id: str) -> PydanticUser:
+        """Fetch a user by ID asynchronously."""
+        async with db_registry.async_session() as session:
+            user = await UserModel.read_async(db_session=session, identifier=actor_id)
+            return user.to_pydantic()
+
     @enforce_types
     def get_default_user(self) -> PydanticUser:
         """Fetch the default user. If it doesn't exist, create it."""
@@ -96,6 +135,26 @@ class UserManager:
         except NoResultFound:
             return self.get_default_user()
 
+    @enforce_types
+    async def get_default_actor_async(self) -> PydanticUser:
+        """Fetch the default user asynchronously. If it doesn't exist, create it."""
+        try:
+            return await self.get_actor_by_id_async(self.DEFAULT_USER_ID)
+        except NoResultFound:
+            # Fall back to synchronous version since create_default_user isn't async yet
+            return self.create_default_user(org_id=self.DEFAULT_ORG_ID)
+
+    @enforce_types
+    async def get_actor_or_default_async(self, actor_id: Optional[str] = None):
+        """Fetch the user or default user asynchronously."""
+        if not actor_id:
+            return await self.get_default_actor_async()
+
+        try:
+            return await self.get_actor_by_id_async(actor_id=actor_id)
+        except NoResultFound:
+            return await self.get_default_actor_async()
+
     @enforce_types
     def list_users(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticUser]:
         """List all users with optional pagination."""
@@ -106,3 +165,14 @@ class UserManager:
                 limit=limit,
             )
             return [user.to_pydantic() for user in users]
+
+    @enforce_types
+    async def list_actors_async(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticUser]:
+        """List all users with optional pagination (async version)."""
+        async with db_registry.async_session() as session:
+            users = await UserModel.list_async(
+                db_session=session,
+                after=after,
+                limit=limit,
+            )
+            return [user.to_pydantic() for user in users]

{letta_nightly-0.7.16.dev20250515205957.dist-info → letta_nightly-0.7.17.dev20250516090339.dist-info}/METADATA

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

{letta_nightly-0.7.16.dev20250515205957.dist-info → letta_nightly-0.7.17.dev20250516090339.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=VzN4jgBctZzrLd4VJNhes1fZyqASwzLbNuO-LeaGUNo,916
+letta/__init__.py,sha256=P8KgAQ7KWTfdnf40ctwC28i6fsLOCgFMMT1GAU26_gE,916
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=7f_vLO0b6pbCoXXzvgSIifViGRpg1MzeiesudknZyLk,72618
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -6,7 +6,7 @@ letta/agents/base_agent.py,sha256=ZmuSpYF8a5I0QXs8LDgS4jaA9k-6Pu2W-hl4E8A1ELo,82
 letta/agents/ephemeral_agent.py,sha256=el-SUF_16vv_7OouIR-6z0pAE9Yc0PLibygvfCKwqfo,2736
 letta/agents/exceptions.py,sha256=BQY4D4w32OYHM63CM19ko7dPwZiAzUs3NbKvzmCTcJg,318
 letta/agents/helpers.py,sha256=qJUmGgwVzNYTmV28sFoUu7MTuyqwzZ4qEpNXHVmSu6s,6055
-letta/agents/letta_agent.py,sha256=XlwvuZ6rMTky6R_oeuQvrocCfVNlfrPD8PfYB9IqYys,20567
+letta/agents/letta_agent.py,sha256=f_DlUwOQ-Uogvb1XgSh63veBFkMotU7Fx1YTeMtyERo,21109
 letta/agents/letta_agent_batch.py,sha256=Z82Me5FV_jQ9PTopUvJ73F4NDFZeiDTgNPTQP5p9BIg,25292
 letta/agents/voice_agent.py,sha256=wCF2adlbDTEk_P3UrGPCHZy4IGvw75TUGDePW6N-sGA,21402
 letta/agents/voice_sleeptime_agent.py,sha256=gB44pOeIQJer_XqdxSNt7Txv0JaQAv9pzsiEFO9GYdY,7346
@@ -64,6 +64,7 @@ letta/interface.py,sha256=6GKasvJMASu-kcZch6Hffz1vnHuPA_ryI6cLH2bMArc,13023
 letta/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/interfaces/anthropic_streaming_interface.py,sha256=w2-adcgT18g_IZgOhjdxIALIHLD_lJrKGG_mx3VWn1c,21118
 letta/interfaces/openai_chat_completions_streaming_interface.py,sha256=LANdVBA8UNWscBvsFbWTT8cxNg5fHA_woWU2jkTf6TQ,4911
+letta/interfaces/openai_streaming_interface.py,sha256=_N_vSs6sSwzzSSjCA8lKdinDlcvcWZDloQa4uFRstvQ,19978
 letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
@@ -160,7 +161,7 @@ letta/orm/provider.py,sha256=KxIyUijtFapxXsgD86tWCRt1sG0TIETEyqlHEUWB7Fg,1312
 letta/orm/sandbox_config.py,sha256=DyOy_1_zCMlp13elCqPcuuA6OwUove6mrjhcpROTg50,4150
 letta/orm/source.py,sha256=rtehzez80rRrJigXeRBgTlfTZEUy6cVqDizWEN2tvuY,2224
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
-letta/orm/sqlalchemy_base.py,sha256=LVHQsrO4JjWWVZ0IaCmgRhonPkkDWOmdHIBPPhb2Pc0,39239
+letta/orm/sqlalchemy_base.py,sha256=AgDqsKfgsQSJjQGXm4VpgSG1ov4NKltlGkuQWuHiECM,41985
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
 letta/orm/step.py,sha256=fjm7fLtYLCtFM6Mj6e2boP6P7dHSFG24Nem85VfVqHg,3216
 letta/orm/tool.py,sha256=ft3BDA7Pt-zsXLyPvS_Z_Ibis6H6vY20F7Li7p6nPu8,2652
@@ -266,25 +267,25 @@ letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=QBWab1fn2LXVDMtc6li3gOzmrNzDiUw5WUJsMeeMZII,5076
 letta/server/rest_api/routers/v1/__init__.py,sha256=_skmAcDOK9ovHKfywRaBgigo3IvPmnUSQSR2hGVCOhY,1664
-letta/server/rest_api/routers/v1/agents.py,sha256=CpHxBFmPiYwpXrhHwEeF0j3ZAIsn_05aUAz1_aCpkCg,35465
-letta/server/rest_api/routers/v1/blocks.py,sha256=XuHdwdWwDm7qdBIVv95MnUcekSEMJ1New_-CEqVZew8,4631
+letta/server/rest_api/routers/v1/agents.py,sha256=EM0bpwJ2Dt3cGIux89N1v5PKxJbooFkLO0IbSmR7FOI,35716
+letta/server/rest_api/routers/v1/blocks.py,sha256=Q0ZWhKiW1lOZmLLXy0IrJpTQ-Hp03psOWdfjJR2uoxI,4645
 letta/server/rest_api/routers/v1/embeddings.py,sha256=P-Dvt_HNKoTyjRwkScAMg1hlB3cNxMeAQwV7bSatsKI,957
-letta/server/rest_api/routers/v1/groups.py,sha256=JI9ShKewoE8lB58OP02NuAT7eUzPfqSG7y44a6tBh9s,10710
+letta/server/rest_api/routers/v1/groups.py,sha256=DT2tc4wwiq_gzmxefltEIrFSoqOntzhvmgqQy23varA,10738
 letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
 letta/server/rest_api/routers/v1/identities.py,sha256=fvp-0cwvb4iX1fUGPkL--9nq8YD3tIE47kYRxUgOlp4,7462
 letta/server/rest_api/routers/v1/jobs.py,sha256=4oeJfI2odNGubU_g7WSORJhn_usFsbRaD-qm86rve1E,2746
 letta/server/rest_api/routers/v1/llms.py,sha256=PZWNHq7QuKj71HzOIzNwLWgATqDQo54K26zzg9dLom0,1683
-letta/server/rest_api/routers/v1/messages.py,sha256=D5YAcU1_df8dPaarjZ_UboPI4yC7HMfr1rn5Nm2Xyp8,7780
+letta/server/rest_api/routers/v1/messages.py,sha256=JvszNvPIe9mArExNInmJkcX33WInMbS5Vlds1eLqkjc,7850
 letta/server/rest_api/routers/v1/organizations.py,sha256=r7rj-cA3shgAgM0b2JCMqjYsDIFv3ruZjU7SYbPGGqg,2831
 letta/server/rest_api/routers/v1/providers.py,sha256=qp6XT20tcZac64XDGF2QUyLhselnShrRcTDQBHExEbQ,4322
-letta/server/rest_api/routers/v1/runs.py,sha256=9nuJRjBtRgZPq3CiCEUA_3S2xPHFP5DsJxIenH5OO34,8847
+letta/server/rest_api/routers/v1/runs.py,sha256=rq-k5kYN0On7VBNSzoPJxZcBf13hZFaDx0IUJJ04_K8,8875
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=9hqnnMwJ3wCwO-Bezu3Xl8i3TDSIuInw3gSeHaKUXfE,8526
 letta/server/rest_api/routers/v1/sources.py,sha256=cNDIckY1zqKUeB9xKg6jIoi-cePzyIew-OHMGeQvyqE,11222
 letta/server/rest_api/routers/v1/steps.py,sha256=ra7ttm7HDs3N52M6s80XdpwiSMTLyf776_SmEILWDvo,3276
 letta/server/rest_api/routers/v1/tags.py,sha256=coydgvL6-9cuG2Hy5Ea7QY3inhTHlsf69w0tcZenBus,880
-letta/server/rest_api/routers/v1/tools.py,sha256=5z1SjL3l8dFYm7Umfy9_01RT8fMGajnXtqxWy09TVME,19574
-letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
-letta/server/rest_api/routers/v1/voice.py,sha256=nSwjoW5Hi9EdScGyRWXpGVooAS0X2G-mOrpLUz0NqNs,1935
+letta/server/rest_api/routers/v1/tools.py,sha256=IyGvDTRDY6UyadcmszqsprtwXKkAnA1C4fJyWCtRlfs,19588
+letta/server/rest_api/routers/v1/users.py,sha256=a0J3Ad8kWHxi3vUJB5r9K2GmiplSABZXwhA83o8HbpI,2367
+letta/server/rest_api/routers/v1/voice.py,sha256=NZa7ksEqXTWSqh7CqmbVMClO7wOmrqlRnSqFi6Qh-WM,1949
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=n5ZwtCtF3Oa4b9NFQ8l9f13v4eOI4mWdWNQqFp5d3A0,16516
 letta/server/server.py,sha256=ccbYv9c6xZNbLU3JQ7bgBthPvbl61fodubHDNRsnJxI,89795
@@ -301,7 +302,7 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=3uWOSLwpwBBrNLC4aJhxQZahPccNDXROAp0iCoqyCJo,91707
+letta/services/agent_manager.py,sha256=bcQRrWjECZCoIUD67LLh3XO7AY-9tRDfOY5d8OgmVNg,91590
 letta/services/block_manager.py,sha256=VxiDoshWbM27HQH9AqGQc4x1tsgjz8Csm-TBYiLy3IE,20779
 letta/services/group_manager.py,sha256=X5Z-0j9h95H5p3kKo8m5FZbl0HFN1slxFvcph7fTdvc,15833
 letta/services/helpers/agent_manager_helper.py,sha256=q7GfVgKI-e8k0BZS-V_PuUCjK-PYciZDoig_sYHi_Go,21334
@@ -314,9 +315,9 @@ letta/services/mcp/base_client.py,sha256=YoRb9eKKTGaLxaMVtuH5UcC74iXyWlcyYbC5xOe
 letta/services/mcp/sse_client.py,sha256=Vj0AgaadgMnpFQOWkSoPfeOI00ZvURMf3TIU7fv_DN8,1012
 letta/services/mcp/stdio_client.py,sha256=wdPzTqSRkibjt9pXhwi0Nul_z_cTAPim-OHjLc__yBE,925
 letta/services/mcp/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
-letta/services/message_manager.py,sha256=XVbmuQ9U1OJ2Fh3EE_9WKItWlCpYjAgyKWjAil1eC-M,20733
+letta/services/message_manager.py,sha256=JENrzGpPIGX9STMnqktmbGX9C8ttI9MthQWlea3JphM,21274
 letta/services/organization_manager.py,sha256=Z87kY22pWm6yOmPJCsMUVQmu0kaxyK8WGKkyYaRM2sU,3760
-letta/services/passage_manager.py,sha256=dyaZdNZtuftwDrFyy8Sjv8UGmZAbHJTHgAJVdTzpua0,9924
+letta/services/passage_manager.py,sha256=6-mVw6C1TWFJuaoE1CE8xaaiCPJLptfTb3k9XbhxGPQ,10419
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/provider_manager.py,sha256=l5gfCLMQ5imSoS1xT-6uFqNWEHBqXEriy6VRNkuJZ80,4758
 letta/services/sandbox_config_manager.py,sha256=tN6TYyOSNOZ3daX2QdbJcyGtUvczQc3-YZ-7dn5yLyE,13300
@@ -334,7 +335,7 @@ letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 letta/services/tool_sandbox/base.py,sha256=pUnPFkEg9I5ktMuT4AOOxbTnTmZTGcTA2phLe1H1EdY,8306
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=umsXfolzM_j67izswECDdVfnlcm03wLpMoZtS6SZ0sc,6147
 letta/services/tool_sandbox/local_sandbox.py,sha256=ksbraC-zcMWt3vS7kSi98uWI9L73I0h73rMayhuTWsw,10474
-letta/services/user_manager.py,sha256=lMOBMsFVrUgzlo6Y0b7O9geH3a0wpKuIJnRlGCqQ4oQ,4292
+letta/services/user_manager.py,sha256=fDtPq8q2_LrIPHyn4zyx0orrCqKlpZRoqPU_IIaiBBc,7549
 letta/settings.py,sha256=h0d3tN3W3dEri5xlBthGwDUQBwaz_oZopy2vwRiILXA,8770
 letta/streaming_interface.py,sha256=c-T7zoMTXGXFwDWJJXrv7UypeMPXwPOmNHeuuh0b9zk,16398
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
@@ -342,8 +343,8 @@ letta/system.py,sha256=mKxmvvekuP8mdgsebRINGBoFbUdJhxLJ260crPBNVyk,8386
 letta/tracing.py,sha256=j9uyBbx02erQZ307XmZmZSNyzQt-d7ZDB7vhFhjDlsU,8448
 letta/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/utils.py,sha256=W8J1FfhRADFqoyx3J8-Z1_aWyG433PBoEh_b5wdOZIg,32262
-letta_nightly-0.7.16.dev20250515205957.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.16.dev20250515205957.dist-info/METADATA,sha256=W3hd7GtM8raTDhyVmNpNxHkMy8Y80ot2YYC-mA_YOHA,22274
-letta_nightly-0.7.16.dev20250515205957.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.16.dev20250515205957.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.16.dev20250515205957.dist-info/RECORD,,
+letta_nightly-0.7.17.dev20250516090339.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.17.dev20250516090339.dist-info/METADATA,sha256=fnOCAqQ2y95z92UXfHUiu32N_8UF-Zr6AExf_cqf7TI,22274
+letta_nightly-0.7.17.dev20250516090339.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.17.dev20250516090339.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.17.dev20250516090339.dist-info/RECORD,,