letta-nightly 0.6.21.dev20250205104040__py3-none-any.whl → 0.6.22.dev20250206104042__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.21"
+__version__ = "0.6.22"
 
 
 # import clients

letta/agent.py

@@ -505,8 +505,9 @@ class Agent(BaseAgent):
                 function_response, sandbox_run_result = self.execute_tool_and_persist_state(function_name, function_args, target_letta_tool)
 
                 if sandbox_run_result and sandbox_run_result.status == "error":
-                    error_msg = f"Error calling function {function_name} with args {function_args}: {sandbox_run_result.stderr}"
-                    messages = self._handle_function_error_response(error_msg, tool_call_id, function_name, function_response, messages)
+                    messages = self._handle_function_error_response(
+                        function_response, tool_call_id, function_name, function_response, messages
+                    )
                     return messages, False, True  # force a heartbeat to allow agent to handle error
 
                 # handle trunction
@@ -790,6 +791,7 @@ class Agent(BaseAgent):
                 actor=self.user,
                 provider_name=self.agent_state.llm_config.model_endpoint_type,
                 model=self.agent_state.llm_config.model,
+                model_endpoint=self.agent_state.llm_config.model_endpoint,
                 context_window_limit=self.agent_state.llm_config.context_window,
                 usage=response.usage,
                 # TODO(@caren): Add full provider support - this line is a workaround for v0 BYOK feature

letta/client/client.py

@@ -463,7 +463,7 @@ class RESTClient(AbstractClient):
         if token:
             self.headers = {"accept": "application/json", "Authorization": f"Bearer {token}"}
         elif password:
-            self.headers = {"accept": "application/json", "X-BARE-PASSWORD": f"password {password}"}
+            self.headers = {"accept": "application/json", "Authorization": f"Bearer {password}"}
         else:
             self.headers = {"accept": "application/json"}
         if headers:

letta/constants.py

@@ -53,6 +53,7 @@ BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_all_tags", "send_message_to_agent_async"]
 MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES = 3
 MULTI_AGENT_SEND_MESSAGE_TIMEOUT = 20 * 60
+MULTI_AGENT_CONCURRENT_SENDS = 15
 
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)

letta/functions/function_sets/multi_agent.py

@@ -1,11 +1,13 @@
 import asyncio
 from typing import TYPE_CHECKING, List
 
-from letta.constants import MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES, MULTI_AGENT_SEND_MESSAGE_TIMEOUT
-from letta.functions.helpers import async_send_message_with_retries, execute_send_message_to_agent, fire_and_forget_send_to_agent
+from letta.functions.helpers import (
+    _send_message_to_agents_matching_all_tags_async,
+    execute_send_message_to_agent,
+    fire_and_forget_send_to_agent,
+)
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import MessageCreate
-from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
     from letta.agent import Agent
@@ -22,12 +24,13 @@ def send_message_to_agent_and_wait_for_reply(self: "Agent", message: str, other_
     Returns:
         str: The response from the target agent.
     """
-    message = (
+    augmented_message = (
         f"[Incoming message from agent with ID '{self.agent_state.id}' - to reply to this message, "
         f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
         f"{message}"
     )
-    messages = [MessageCreate(role=MessageRole.system, content=message, name=self.agent_state.name)]
+    messages = [MessageCreate(role=MessageRole.system, content=augmented_message, name=self.agent_state.name)]
+
     return execute_send_message_to_agent(
         sender_agent=self,
         messages=messages,
@@ -81,33 +84,4 @@ def send_message_to_agents_matching_all_tags(self: "Agent", message: str, tags:
         have an entry in the returned list.
     """
 
-    server = get_letta_server()
-
-    message = (
-        f"[Incoming message from agent with ID '{self.agent_state.id}' - to reply to this message, "
-        f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
-        f"{message}"
-    )
-
-    # Retrieve agents that match ALL specified tags
-    matching_agents = server.agent_manager.list_agents(actor=self.user, tags=tags, match_all_tags=True, limit=100)
-    messages = [MessageCreate(role=MessageRole.system, content=message, name=self.agent_state.name)]
-
-    async def send_messages_to_all_agents():
-        tasks = [
-            async_send_message_with_retries(
-                server=server,
-                sender_agent=self,
-                target_agent_id=agent_state.id,
-                messages=messages,
-                max_retries=MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES,
-                timeout=MULTI_AGENT_SEND_MESSAGE_TIMEOUT,
-                logging_prefix="[send_message_to_agents_matching_all_tags]",
-            )
-            for agent_state in matching_agents
-        ]
-        # Run all tasks in parallel
-        return await asyncio.gather(*tasks)
-
-    # Run the async function and return results
-    return asyncio.run(send_messages_to_all_agents())
+    return asyncio.run(_send_message_to_agents_matching_all_tags_async(self, message, tags))

letta/functions/helpers.py

@@ -1,5 +1,4 @@
 import asyncio
-import json
 import threading
 from random import uniform
 from typing import Any, List, Optional, Union
@@ -12,13 +11,17 @@ from letta.constants import (
     COMPOSIO_ENTITY_ENV_VAR_KEY,
     DEFAULT_MESSAGE_TOOL,
     DEFAULT_MESSAGE_TOOL_KWARG,
+    MULTI_AGENT_CONCURRENT_SENDS,
     MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES,
     MULTI_AGENT_SEND_MESSAGE_TIMEOUT,
 )
+from letta.functions.interface import MultiAgentMessagingInterface
 from letta.orm.errors import NoResultFound
-from letta.schemas.letta_message import AssistantMessage, ReasoningMessage, ToolCallMessage
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import AssistantMessage
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 
 
@@ -249,85 +252,94 @@ def generate_import_code(module_attr_map: Optional[dict]):
 def parse_letta_response_for_assistant_message(
     target_agent_id: str,
     letta_response: LettaResponse,
-    assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
-    assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
 ) -> Optional[str]:
     messages = []
-    # This is not ideal, but we would like to return something rather than nothing
-    fallback_reasoning = []
     for m in letta_response.messages:
         if isinstance(m, AssistantMessage):
             messages.append(m.content)
-        elif isinstance(m, ToolCallMessage) and m.tool_call.name == assistant_message_tool_name:
-            try:
-                messages.append(json.loads(m.tool_call.arguments)[assistant_message_tool_kwarg])
-            except Exception:  # TODO: Make this more specific
-                continue
-        elif isinstance(m, ReasoningMessage):
-            fallback_reasoning.append(m.reasoning)
 
     if messages:
         messages_str = "\n".join(messages)
-        return f"Agent {target_agent_id} said: '{messages_str}'"
+        return f"{target_agent_id} said: '{messages_str}'"
     else:
-        messages_str = "\n".join(fallback_reasoning)
-        return f"Agent {target_agent_id}'s inner thoughts: '{messages_str}'"
+        return f"No response from {target_agent_id}"
 
 
-def execute_send_message_to_agent(
+async def async_execute_send_message_to_agent(
     sender_agent: "Agent",
     messages: List[MessageCreate],
     other_agent_id: str,
     log_prefix: str,
 ) -> Optional[str]:
     """
-    Helper function to send a message to a specific Letta agent.
-
-    Args:
-        sender_agent ("Agent"): The sender agent object.
-        message (str): The message to send.
-        other_agent_id (str): The identifier of the target Letta agent.
-        log_prefix (str): Logging prefix for retries.
-
-    Returns:
-        Optional[str]: The response from the Letta agent if required by the caller.
+    Async helper to:
+      1) validate the target agent exists & is in the same org,
+      2) send a message via async_send_message_with_retries.
     """
     server = get_letta_server()
 
-    # Ensure the target agent is in the same org
+    # 1. Validate target agent
     try:
         server.agent_manager.get_agent_by_id(agent_id=other_agent_id, actor=sender_agent.user)
     except NoResultFound:
-        raise ValueError(
-            f"The passed-in agent_id {other_agent_id} either does not exist, "
-            f"or does not belong to the same org ({sender_agent.user.organization_id})."
-        )
+        raise ValueError(f"Target agent {other_agent_id} either does not exist or is not in org " f"({sender_agent.user.organization_id}).")
 
-    # Async logic to send a message with retries and timeout
-    async def async_send():
-        return await async_send_message_with_retries(
-            server=server,
-            sender_agent=sender_agent,
-            target_agent_id=other_agent_id,
-            messages=messages,
-            max_retries=MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES,
-            timeout=MULTI_AGENT_SEND_MESSAGE_TIMEOUT,
-            logging_prefix=log_prefix,
-        )
+    # 2. Use your async retry logic
+    return await async_send_message_with_retries(
+        server=server,
+        sender_agent=sender_agent,
+        target_agent_id=other_agent_id,
+        messages=messages,
+        max_retries=MULTI_AGENT_SEND_MESSAGE_MAX_RETRIES,
+        timeout=MULTI_AGENT_SEND_MESSAGE_TIMEOUT,
+        logging_prefix=log_prefix,
+    )
 
-    # Run in the current event loop or create one if needed
-    try:
-        return asyncio.run(async_send())
-    except RuntimeError:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            return loop.run_until_complete(async_send())
-        else:
-            raise
+
+def execute_send_message_to_agent(
+    sender_agent: "Agent",
+    messages: List[MessageCreate],
+    other_agent_id: str,
+    log_prefix: str,
+) -> Optional[str]:
+    """
+    Synchronous wrapper that calls `async_execute_send_message_to_agent` using asyncio.run.
+    This function must be called from a synchronous context (i.e., no running event loop).
+    """
+    return asyncio.run(async_execute_send_message_to_agent(sender_agent, messages, other_agent_id, log_prefix))
+
+
+async def send_message_to_agent_no_stream(
+    server: "SyncServer",
+    agent_id: str,
+    actor: User,
+    messages: Union[List[Message], List[MessageCreate]],
+    metadata: Optional[dict] = None,
+) -> LettaResponse:
+    """
+    A simpler helper to send messages to a single agent WITHOUT streaming.
+    Returns a LettaResponse containing the final messages.
+    """
+    interface = MultiAgentMessagingInterface()
+    if metadata:
+        interface.metadata = metadata
+
+    # Offload the synchronous `send_messages` call
+    usage_stats = await asyncio.to_thread(
+        server.send_messages,
+        actor=actor,
+        agent_id=agent_id,
+        messages=messages,
+        interface=interface,
+        metadata=metadata,
+    )
+
+    final_messages = interface.get_captured_send_messages()
+    return LettaResponse(messages=final_messages, usage=usage_stats)
 
 
 async def async_send_message_with_retries(
-    server,
+    server: "SyncServer",
     sender_agent: "Agent",
     target_agent_id: str,
     messages: List[MessageCreate],
@@ -335,57 +347,34 @@ async def async_send_message_with_retries(
     timeout: int,
     logging_prefix: Optional[str] = None,
 ) -> str:
-    """
-    Shared helper coroutine to send a message to an agent with retries and a timeout.
 
-    Args:
-        server: The Letta server instance (from get_letta_server()).
-        sender_agent (Agent): The agent initiating the send action.
-        target_agent_id (str): The ID of the agent to send the message to.
-        message_text (str): The text to send as the user message.
-        max_retries (int): Maximum number of retries for the request.
-        timeout (int): Maximum time to wait for a response (in seconds).
-        logging_prefix (str): A prefix to append to logging
-    Returns:
-        str: The response or an error message.
-    """
     logging_prefix = logging_prefix or "[async_send_message_with_retries]"
     for attempt in range(1, max_retries + 1):
         try:
-            # Wrap in a timeout
             response = await asyncio.wait_for(
-                server.send_message_to_agent(
+                send_message_to_agent_no_stream(
+                    server=server,
                     agent_id=target_agent_id,
                     actor=sender_agent.user,
                     messages=messages,
-                    stream_steps=False,
-                    stream_tokens=False,
-                    use_assistant_message=True,
-                    assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
-                    assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
                 ),
                 timeout=timeout,
             )
 
-            # Extract assistant message
-            assistant_message = parse_letta_response_for_assistant_message(
-                target_agent_id,
-                response,
-                assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
-                assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
-            )
+            # Then parse out the assistant message
+            assistant_message = parse_letta_response_for_assistant_message(target_agent_id, response)
             if assistant_message:
                 sender_agent.logger.info(f"{logging_prefix} - {assistant_message}")
                 return assistant_message
             else:
                 msg = f"(No response from agent {target_agent_id})"
                 sender_agent.logger.info(f"{logging_prefix} - {msg}")
-                sender_agent.logger.info(f"{logging_prefix} - raw response: {response.model_dump_json(indent=4)}")
-                sender_agent.logger.info(f"{logging_prefix} - parsed assistant message: {assistant_message}")
                 return msg
+
         except asyncio.TimeoutError:
             error_msg = f"(Timeout on attempt {attempt}/{max_retries} for agent {target_agent_id})"
             sender_agent.logger.warning(f"{logging_prefix} - {error_msg}")
+
         except Exception as e:
             error_msg = f"(Error on attempt {attempt}/{max_retries} for agent {target_agent_id}: {e})"
             sender_agent.logger.warning(f"{logging_prefix} - {error_msg}")
@@ -393,10 +382,10 @@ async def async_send_message_with_retries(
         # Exponential backoff before retrying
         if attempt < max_retries:
             backoff = uniform(0.5, 2) * (2**attempt)
-            sender_agent.logger.warning(f"{logging_prefix} - Retrying the agent to agent send_message...sleeping for {backoff}")
+            sender_agent.logger.warning(f"{logging_prefix} - Retrying the agent-to-agent send_message...sleeping for {backoff}")
             await asyncio.sleep(backoff)
         else:
-            sender_agent.logger.error(f"{logging_prefix} - Fatal error during agent to agent send_message: {error_msg}")
+            sender_agent.logger.error(f"{logging_prefix} - Fatal error: {error_msg}")
             raise Exception(error_msg)
 
 
@@ -482,3 +471,43 @@ def fire_and_forget_send_to_agent(
     except RuntimeError:
         # Means no event loop is running in this thread
         run_in_background_thread(background_task())
+
+
+async def _send_message_to_agents_matching_all_tags_async(sender_agent: "Agent", message: str, tags: List[str]) -> List[str]:
+    server = get_letta_server()
+
+    augmented_message = (
+        f"[Incoming message from agent with ID '{sender_agent.agent_state.id}' - to reply to this message, "
+        f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
+        f"{message}"
+    )
+
+    # Retrieve up to 100 matching agents
+    matching_agents = server.agent_manager.list_agents(actor=sender_agent.user, tags=tags, match_all_tags=True, limit=100)
+
+    # Create a system message
+    messages = [MessageCreate(role=MessageRole.system, content=augmented_message, name=sender_agent.agent_state.name)]
+
+    # Possibly limit concurrency to avoid meltdown:
+    sem = asyncio.Semaphore(MULTI_AGENT_CONCURRENT_SENDS)
+
+    async def _send_single(agent_state):
+        async with sem:
+            return await async_send_message_with_retries(
+                server=server,
+                sender_agent=sender_agent,
+                target_agent_id=agent_state.id,
+                messages=messages,
+                max_retries=3,
+                timeout=30,
+            )
+
+    tasks = [asyncio.create_task(_send_single(agent_state)) for agent_state in matching_agents]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    final = []
+    for r in results:
+        if isinstance(r, Exception):
+            final.append(str(r))
+        else:
+            final.append(r)
+    return final

letta/functions/interface.py

@@ -0,0 +1,75 @@
+import json
+from typing import List, Optional
+
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.interface import AgentInterface
+from letta.schemas.letta_message import AssistantMessage, LettaMessage
+from letta.schemas.message import Message
+
+
+class MultiAgentMessagingInterface(AgentInterface):
+    """
+    A minimal interface that captures *only* calls to the 'send_message' function
+    by inspecting msg_obj.tool_calls. We parse out the 'message' field from the
+    JSON function arguments and store it as an AssistantMessage.
+    """
+
+    def __init__(self):
+        self._captured_messages: List[AssistantMessage] = []
+        self.metadata = {}
+
+    def internal_monologue(self, msg: str, msg_obj: Optional[Message] = None):
+        """Ignore internal monologue."""
+
+    def assistant_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """Ignore normal assistant messages (only capturing send_message calls)."""
+
+    def function_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """
+        Called whenever the agent logs a function call. We'll inspect msg_obj.tool_calls:
+          - If tool_calls include a function named 'send_message', parse its arguments
+          - Extract the 'message' field
+          - Save it as an AssistantMessage in self._captured_messages
+        """
+        if not msg_obj or not msg_obj.tool_calls:
+            return
+
+        for tool_call in msg_obj.tool_calls:
+            if not tool_call.function:
+                continue
+            if tool_call.function.name != DEFAULT_MESSAGE_TOOL:
+                # Skip any other function calls
+                continue
+
+            # Now parse the JSON in tool_call.function.arguments
+            func_args_str = tool_call.function.arguments or ""
+            try:
+                data = json.loads(func_args_str)
+                # Extract the 'message' key if present
+                content = data.get(DEFAULT_MESSAGE_TOOL_KWARG, str(data))
+            except json.JSONDecodeError:
+                # If we can't parse, store the raw string
+                content = func_args_str
+
+            # Store as an AssistantMessage
+            new_msg = AssistantMessage(
+                id=msg_obj.id,
+                date=msg_obj.created_at,
+                content=content,
+            )
+            self._captured_messages.append(new_msg)
+
+    def user_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """Ignore user messages."""
+
+    def step_complete(self):
+        """No streaming => no step boundaries."""
+
+    def step_yield(self):
+        """No streaming => no final yield needed."""
+
+    def get_captured_send_messages(self) -> List[LettaMessage]:
+        """
+        Returns only the messages extracted from 'send_message' calls.
+        """
+        return self._captured_messages

letta/orm/step.py

@@ -35,6 +35,7 @@ class Step(SqlalchemyBase):
     )
     provider_name: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the provider used for this step.")
     model: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the model used for this step.")
+    model_endpoint: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The model endpoint url used for this step.")
     context_window_limit: Mapped[Optional[int]] = mapped_column(
         None, nullable=True, doc="The context window limit configured for this step."
     )

letta/schemas/step.py

@@ -20,6 +20,7 @@ class Step(StepBase):
     )
     provider_name: Optional[str] = Field(None, description="The name of the provider used for this step.")
     model: Optional[str] = Field(None, description="The name of the model used for this step.")
+    model_endpoint: Optional[str] = Field(None, description="The model endpoint url used for this step.")
     context_window_limit: Optional[int] = Field(None, description="The context window limit configured for this step.")
     completion_tokens: Optional[int] = Field(None, description="The number of tokens generated by the agent during this step.")
     prompt_tokens: Optional[int] = Field(None, description="The number of tokens in the prompt during this step.")

letta/server/rest_api/interface.py

@@ -315,7 +315,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         # extra prints
         self.debug = False
-        self.timeout = 30
+        self.timeout = 10 * 60  # 10 minute timeout
 
     def _reset_inner_thoughts_json_reader(self):
         # A buffer for accumulating function arguments (we want to buffer keys and run checks on each one)
@@ -330,7 +330,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         while self._active:
             try:
                 # Wait until there is an item in the deque or the stream is deactivated
-                await asyncio.wait_for(self._event.wait(), timeout=self.timeout)  # 30 second timeout
+                await asyncio.wait_for(self._event.wait(), timeout=self.timeout)
             except asyncio.TimeoutError:
                 break  # Exit the loop if we timeout
 

letta/services/step_manager.py

@@ -55,6 +55,7 @@ class StepManager:
         actor: PydanticUser,
         provider_name: str,
         model: str,
+        model_endpoint: Optional[str],
         context_window_limit: int,
         usage: UsageStatistics,
         provider_id: Optional[str] = None,
@@ -66,6 +67,7 @@ class StepManager:
             "provider_id": provider_id,
             "provider_name": provider_name,
             "model": model,
+            "model_endpoint": model_endpoint,
             "context_window_limit": context_window_limit,
             "completion_tokens": usage.completion_tokens,
             "prompt_tokens": usage.prompt_tokens,

{letta_nightly-0.6.21.dev20250205104040.dist-info → letta_nightly-0.6.22.dev20250206104042.dist-info}/METADATA

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

{letta_nightly-0.6.21.dev20250205104040.dist-info → letta_nightly-0.6.22.dev20250206104042.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=bjhntPdDAWCs4iINZfoEzpfEiEU32NSYtCmSvdcL3gk,919
+letta/__init__.py,sha256=HRAHARA2DybG2umdS9hdIE5OxZULncZxurOtMCJRHao,919
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=Ds5-t_Ge1ZJf8wbQ2LbpK9LHEs6XNu0xLow3iXoZpd8,56980
+letta/agent.py,sha256=xOhzNF-DMxBzCkADyw1-OILsxfy2gMBkV0CoQ3XfW_I,56980
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=71Lf-df8y3nsE9IFKpEigaZaWHoWnXnhVChkp1L-83I,4760
@@ -8,11 +8,11 @@ letta/cli/cli.py,sha256=_uGKM-RvGLGf7y8iWjkLgLTxIw7uWrdCdL5ETUOCkUs,16472
 letta/cli/cli_config.py,sha256=2oo4vui1GXQarAD6Ru4SRzPvcW4eX2mCXOBusfYGvJw,8533
 letta/cli/cli_load.py,sha256=xFw-CuzjChcIptaqQ1XpDROENt0JSjyPeiQ0nmEeO1k,2706
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=Vzjq3a5dx9W5R96FvKkohHf2Yf0NV4XG0VWTH2h0624,138315
+letta/client/client.py,sha256=ZgJEt5F1yB6Q_z9Qi0FJ7Vmlb-YK41tymSKFB7NWy38,138311
 letta/client/streaming.py,sha256=DzE86XJTg_0j9eC45Hrpy9vPt-Wfo1F-sIv_B7iNV6I,5509
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
-letta/constants.py,sha256=SafL4BPMDzzVhp-Y6Uu51NaZAzOuUAoJhbKYpzbQZoQ,7242
+letta/constants.py,sha256=ZyPGoe68NfBCteTQI6hX9aFhszuBvy10xakb2FFKV9M,7276
 letta/data_sources/connectors.py,sha256=R2AssXpqS7wN6VI8AfxvqaZs5S1ZACc4E_FewmR9iZI,7022
 letta/data_sources/connectors_helper.py,sha256=2TQjCt74fCgT5sw1AP8PalDEk06jPBbhrPG4HVr-WLs,3371
 letta/embeddings.py,sha256=VgqbUqYL6oTuLOKGOd_8swTRMYIpRTIWJbBthjT8eR8,8838
@@ -21,9 +21,10 @@ letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/ast_parsers.py,sha256=MEFfGxpflUsw34JiY9zdunkpbczAYxte8t4rDPOmXfQ,3620
 letta/functions/function_sets/base.py,sha256=bOiitkhzqYKwZBiRYrx29AlordiA5IrXw25eVSRK8BY,5984
 letta/functions/function_sets/extras.py,sha256=Z9yEdBpQFtTjpxkgbtkWMA8GtDWC6ai2bdsRpnv0H_w,4837
-letta/functions/function_sets/multi_agent.py,sha256=2tu7A_eMwkfXldZWpfwwnq0OXPFTjROo-NjXvuhxOhc,5357
+letta/functions/function_sets/multi_agent.py,sha256=BcMeod0-lMhnKeaVWJp2T1PzRV0qvCuTWAPMJxAbgHI,4073
 letta/functions/functions.py,sha256=NyWLh7a-f4mXti5vM1oWDwXzfA58VmVVqL03O9vosKY,5672
-letta/functions/helpers.py,sha256=5f4ua21fffqU-M24ha2xNGrqIhqLWh0-sTNFOHbu18Q,19700
+letta/functions/helpers.py,sha256=-DpUikW56Asps1XaRx4CEiTNc-DuLGgBgFYbNBO_37U,19964
+letta/functions/interface.py,sha256=s_PPp5WDvGH_y9KUpMlORkdC141ITczFk3wsevrrUD8,2866
 letta/functions/schema_generator.py,sha256=qosgp3p27QRTqOCPLrSkCGVdyQsyTTZunXQ_g-YaTkw,20138
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/tool_rule_solver.py,sha256=VnJfqb5L1Lcipc_tBVGj0om60GKQkMkNLgg6X9VZl2c,6210
@@ -108,7 +109,7 @@ letta/orm/source.py,sha256=cpaleNiP-DomM2oopwgL2DGn38ITQwLMs5mKODf_c_4,2167
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
 letta/orm/sqlalchemy_base.py,sha256=jhhF3A_k5j3wxyZ-C_n6kwvQIZ1iU3-vvcke3QarLBA,21901
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
-letta/orm/step.py,sha256=6ygEnkQSIMxNH08Om0a-UK-f2E66QSpp9GdGm7mGjFg,2853
+letta/orm/step.py,sha256=6t_PlVd8pW1Rd6JeECImBG2n9P-yif0Sl9Uzhb-m77w,2982
 letta/orm/tool.py,sha256=JEPHlM4ePaLaGtHpHhYdKCteHTRJnOFgQmfR5wL8TpA,2379
 letta/orm/tools_agents.py,sha256=r6t-V21w2_mG8n38zuUb5jOi_3hRxsjgezsLA4sg0m4,626
 letta/orm/user.py,sha256=rK5N5ViDxmesZMqVVHB7FcQNpcSoM-hB42MyI6q3MnI,1004
@@ -167,7 +168,7 @@ letta/schemas/providers.py,sha256=1Sc7gWI6n9RkR4kOY4g3xGLVo6VCSwpiJySp3Pm3MQw,34
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Nz8K5brqe6jpf66KnTJ0-E7ZeFdPoBFGN-XOI35OeaY,5926
 letta/schemas/source.py,sha256=-BQVolcXA2ziCu2ztR6cbTdGUc8G7vGJy7rvpdf1hpg,2880
-letta/schemas/step.py,sha256=cCmDChQMndy7aMJGH0Z19VbzJkAeFTYuA0cJpzjW2g0,1928
+letta/schemas/step.py,sha256=wQ-AzhMjH7tLFgZbJfcPkW9a9V81JYWzJCQtTfcb11E,2034
 letta/schemas/tool.py,sha256=dDyzvLZ_gw9DdcFplGTHoH9aFQnF2ez-ApYLRtxAfys,11051
 letta/schemas/tool_rule.py,sha256=tS7ily6NJD8E4n7Hla38jMUe6OIdhdc1ckq0AiRpu5Y,1893
 letta/schemas/usage.py,sha256=8oYRH-JX0PfjIu2zkT5Uu3UWQ7Unnz_uHiO8hRGI4m0,912
@@ -181,7 +182,7 @@ letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
 letta/server/rest_api/chat_completions_interface.py,sha256=i9tfb9oSh14QNY-1ghWYtdgP7_RiyPHD5NcA2FKF3Dw,10195
-letta/server/rest_api/interface.py,sha256=5lf5k5GJgUaRb8NCKotSK5PZDAcpYFmKjyPlMqtc964,51881
+letta/server/rest_api/interface.py,sha256=ZGTJ5WIRNsWgKO0yoCD-yUESxq838qNrK3N1SzRZl40,51886
 letta/server/rest_api/optimistic_json_parser.py,sha256=1z4d9unmxMb0ou7owJ62uUQoNjNYf21FmaNdg0ZcqUU,6567
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -229,7 +230,7 @@ letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1H
 letta/services/provider_manager.py,sha256=jEal0A0XWobWH5CVfmzPtcFhsflI-sanqyg26FqpDKk,3575
 letta/services/sandbox_config_manager.py,sha256=eWDNTscRG9Gt_Ixho3-daOOno_9KcebxeA9v_CbzYu0,13371
 letta/services/source_manager.py,sha256=0JLKIv405oS5wc6bY5k2bxxZpS9O-VwUGHVdGPbJ3e4,7676
-letta/services/step_manager.py,sha256=dvGFeobB7TjXBENG6pGrEr6tEil3Am7GyTzv2IjQifA,4885
+letta/services/step_manager.py,sha256=_PJUgaXyUHKCdlwt9CAmKhdeCNzKE_0_8-SRdUzpZaA,4970
 letta/services/tool_execution_sandbox.py,sha256=4XBYkCEBLG6GqijxgqeLIQQJ9zRbsJa8vZ4dZG04Pq8,22080
 letta/services/tool_manager.py,sha256=9Y15q0GqnADk-tnUeWDFFsDOt_ZjwsPU2oteDVtHAF4,9572
 letta/services/user_manager.py,sha256=1U8BQ_-MBkEW2wnSFV_OsTwBmRAZLN8uHLFjnDjK3hA,4308
@@ -238,8 +239,8 @@ letta/streaming_interface.py,sha256=lo2VAQRUJOdWTijwnXuKOC9uejqr2siUAEmZiQUXkj8,
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
 letta/system.py,sha256=S_0cod77iEttkFd1bSh2wenLCKA8YL487AuVenIDUng,8425
 letta/utils.py,sha256=lgBDWKmrQrmJGPxcgamFC2aJyi6I0dX7bzLBt3YC6j0,34051
-letta_nightly-0.6.21.dev20250205104040.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.21.dev20250205104040.dist-info/METADATA,sha256=9rpeMVxKdfJXbURcCQGwwSN4GpfbrhegKoWkn-axrJw,22156
-letta_nightly-0.6.21.dev20250205104040.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.21.dev20250205104040.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.21.dev20250205104040.dist-info/RECORD,,
+letta_nightly-0.6.22.dev20250206104042.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.22.dev20250206104042.dist-info/METADATA,sha256=K80Klxfva98oQxOTPEFh4tJ4-ucJqBjjW1LJxS2_O74,22156
+letta_nightly-0.6.22.dev20250206104042.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.22.dev20250206104042.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.22.dev20250206104042.dist-info/RECORD,,