letta-nightly 0.7.8.dev20250502104219__tar.gz → 0.7.9.dev20250502222710__tar.gz

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.8.dev20250502104219
+Version: 0.7.9.dev20250502222710
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -50,7 +50,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.127,<0.2.0)
+Requires-Dist: letta_client (>=0.1.136,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/__init__.py

@@ -1,9 +1,9 @@
-__version__ = "0.7.8"
+__version__ = "0.7.9"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client
 
-# # imports for easier access
+# imports for easier access
 from letta.schemas.agent import AgentState
 from letta.schemas.block import Block
 from letta.schemas.embedding_config import EmbeddingConfig

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/agents/helpers.py

@@ -1,3 +1,4 @@
+import xml.etree.ElementTree as ET
 from typing import List, Tuple
 
 from letta.schemas.agent import AgentState
@@ -20,7 +21,10 @@ def _create_letta_response(new_in_context_messages: list[Message], use_assistant
 
 
 def _prepare_in_context_messages(
-    input_messages: List[MessageCreate], agent_state: AgentState, message_manager: MessageManager, actor: User
+    input_messages: List[MessageCreate],
+    agent_state: AgentState,
+    message_manager: MessageManager,
+    actor: User,
 ) -> Tuple[List[Message], List[Message]]:
     """
     Prepares in-context messages for an agent, based on the current state and a new user input.
@@ -50,3 +54,56 @@ def _prepare_in_context_messages(
     )
 
     return current_in_context_messages, new_in_context_messages
+
+
+def serialize_message_history(messages: List[str], context: str) -> str:
+    """
+    Produce an XML document like:
+
+    <memory>
+      <messages>
+        <message>…</message>
+        <message>…</message>
+        …
+      </messages>
+      <context>…</context>
+    </memory>
+    """
+    root = ET.Element("memory")
+
+    msgs_el = ET.SubElement(root, "messages")
+    for msg in messages:
+        m = ET.SubElement(msgs_el, "message")
+        m.text = msg
+
+    sum_el = ET.SubElement(root, "context")
+    sum_el.text = context
+
+    # ET.tostring will escape reserved chars for you
+    return ET.tostring(root, encoding="unicode")
+
+
+def deserialize_message_history(xml_str: str) -> Tuple[List[str], str]:
+    """
+    Parse the XML back into (messages, context). Raises ValueError if tags are missing.
+    """
+    try:
+        root = ET.fromstring(xml_str)
+    except ET.ParseError as e:
+        raise ValueError(f"Invalid XML: {e}")
+
+    msgs_el = root.find("messages")
+    if msgs_el is None:
+        raise ValueError("Missing <messages> section")
+
+    messages = []
+    for m in msgs_el.findall("message"):
+        # .text may be None if empty, so coerce to empty string
+        messages.append(m.text or "")
+
+    sum_el = root.find("context")
+    if sum_el is None:
+        raise ValueError("Missing <context> section")
+    context = sum_el.text or ""
+
+    return messages, context

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/agents/letta_agent.py

@@ -62,6 +62,14 @@ class LettaAgent(BaseAgent):
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+        current_in_context_messages, new_in_context_messages = await self._step(
+            agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
+        )
+        return _create_letta_response(new_in_context_messages=new_in_context_messages, use_assistant_message=self.use_assistant_message)
+
+    async def _step(
+        self, agent_state: AgentState, input_messages: List[MessageCreate], max_steps: int = 10
+    ) -> Tuple[List[Message], List[Message]]:
         current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
             input_messages, agent_state, self.message_manager, self.actor
         )
@@ -72,7 +80,7 @@ class LettaAgent(BaseAgent):
             put_inner_thoughts_first=True,
             actor_id=self.actor.id,
         )
-        for step in range(max_steps):
+        for _ in range(max_steps):
             response = await self._get_ai_reply(
                 llm_client=llm_client,
                 in_context_messages=current_in_context_messages + new_in_context_messages,
@@ -83,6 +91,7 @@ class LettaAgent(BaseAgent):
             )
 
             tool_call = response.choices[0].message.tool_calls[0]
+
             persisted_messages, should_continue = await self._handle_ai_response(tool_call, agent_state, tool_rules_solver)
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
@@ -95,7 +104,7 @@ class LettaAgent(BaseAgent):
             message_ids = [m.id for m in (current_in_context_messages + new_in_context_messages)]
             self.agent_manager.set_in_context_messages(agent_id=self.agent_id, message_ids=message_ids, actor=self.actor)
 
-        return _create_letta_response(new_in_context_messages=new_in_context_messages, use_assistant_message=self.use_assistant_message)
+        return current_in_context_messages, new_in_context_messages
 
     @trace_method
     async def step_stream(
@@ -117,7 +126,7 @@ class LettaAgent(BaseAgent):
             actor_id=self.actor.id,
         )
 
-        for step in range(max_steps):
+        for _ in range(max_steps):
             stream = await self._get_ai_reply(
                 llm_client=llm_client,
                 in_context_messages=current_in_context_messages + new_in_context_messages,
@@ -181,6 +190,7 @@ class LettaAgent(BaseAgent):
                 ToolType.LETTA_MEMORY_CORE,
                 ToolType.LETTA_MULTI_AGENT_CORE,
                 ToolType.LETTA_SLEEPTIME_CORE,
+                ToolType.LETTA_VOICE_SLEEPTIME_CORE,
             }
             or (t.tool_type == ToolType.LETTA_MULTI_AGENT_CORE and t.name == "send_message_to_agents_matching_tags")
             or (t.tool_type == ToolType.EXTERNAL_COMPOSIO)

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/agents/letta_agent_batch.py

@@ -137,21 +137,37 @@ class LettaAgentBatch:
         log_event(name="load_and_prepare_agents")
         agent_messages_mapping: Dict[str, List[Message]] = {}
         agent_tools_mapping: Dict[str, List[dict]] = {}
+        # TODO: This isn't optimal, moving fast - prone to bugs because we pass around this half formed pydantic object
+        agent_batch_item_mapping: Dict[str, LLMBatchItem] = {}
         agent_states = []
         for batch_request in batch_requests:
             agent_id = batch_request.agent_id
             agent_state = self.agent_manager.get_agent_by_id(agent_id, actor=self.actor)
             agent_states.append(agent_state)
 
-            agent_messages_mapping[agent_id] = self._get_in_context_messages_per_agent(
-                agent_state=agent_state, input_messages=batch_request.messages
-            )
-
             if agent_id not in agent_step_state_mapping:
                 agent_step_state_mapping[agent_id] = AgentStepState(
                     step_number=0, tool_rules_solver=ToolRulesSolver(tool_rules=agent_state.tool_rules)
                 )
 
+            llm_batch_item = LLMBatchItem(
+                llm_batch_id="",  # TODO: This is hacky, it gets filled in later
+                agent_id=agent_state.id,
+                llm_config=agent_state.llm_config,
+                request_status=JobStatus.created,
+                step_status=AgentStepStatus.paused,
+                step_state=agent_step_state_mapping[agent_id],
+            )
+            agent_batch_item_mapping[agent_id] = llm_batch_item
+
+            # Fill in the batch_item_id for the message
+            for msg in batch_request.messages:
+                msg.batch_item_id = llm_batch_item.id
+
+            agent_messages_mapping[agent_id] = self._prepare_in_context_messages_per_agent(
+                agent_state=agent_state, input_messages=batch_request.messages
+            )
+
             agent_tools_mapping[agent_id] = self._prepare_tools_per_agent(agent_state, agent_step_state_mapping[agent_id].tool_rules_solver)
 
         log_event(name="init_llm_client")
@@ -182,21 +198,14 @@ class LettaAgentBatch:
         log_event(name="prepare_batch_items")
         batch_items = []
         for state in agent_states:
-            step_state = agent_step_state_mapping[state.id]
-            batch_items.append(
-                LLMBatchItem(
-                    llm_batch_id=llm_batch_job.id,
-                    agent_id=state.id,
-                    llm_config=state.llm_config,
-                    request_status=JobStatus.created,
-                    step_status=AgentStepStatus.paused,
-                    step_state=step_state,
-                )
-            )
+            llm_batch_item = agent_batch_item_mapping[state.id]
+            # TODO This is hacky
+            llm_batch_item.llm_batch_id = llm_batch_job.id
+            batch_items.append(llm_batch_item)
 
         if batch_items:
             log_event(name="bulk_create_batch_items")
-            self.batch_manager.create_llm_batch_items_bulk(batch_items, actor=self.actor)
+            batch_items_persisted = self.batch_manager.create_llm_batch_items_bulk(batch_items, actor=self.actor)
 
         log_event(name="return_batch_response")
         return LettaBatchResponse(
@@ -335,9 +344,14 @@ class LettaAgentBatch:
         exec_results: Sequence[Tuple[str, Tuple[str, bool]]],
         ctx: _ResumeContext,
     ) -> Dict[str, List[Message]]:
+        # TODO: This is redundant, we should have this ready on the ctx
+        # TODO: I am doing it quick and dirty for now
+        agent_item_map: Dict[str, LLMBatchItem] = {item.agent_id: item for item in ctx.batch_items}
+
         msg_map: Dict[str, List[Message]] = {}
         for aid, (tool_res, success) in exec_results:
             msgs = self._create_tool_call_messages(
+                llm_batch_item_id=agent_item_map[aid].id,
                 agent_state=ctx.agent_state_map[aid],
                 tool_call_name=ctx.tool_call_name_map[aid],
                 tool_call_args=ctx.tool_call_args_map[aid],
@@ -399,6 +413,7 @@ class LettaAgentBatch:
 
     def _create_tool_call_messages(
         self,
+        llm_batch_item_id: str,
         agent_state: AgentState,
         tool_call_name: str,
         tool_call_args: Dict[str, Any],
@@ -421,6 +436,7 @@ class LettaAgentBatch:
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=None,
             pre_computed_tool_message_id=None,
+            llm_batch_item_id=llm_batch_item_id,
         )
 
         return tool_call_messages
@@ -477,7 +493,7 @@ class LettaAgentBatch:
         valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
         return [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
 
-    def _get_in_context_messages_per_agent(self, agent_state: AgentState, input_messages: List[MessageCreate]) -> List[Message]:
+    def _prepare_in_context_messages_per_agent(self, agent_state: AgentState, input_messages: List[MessageCreate]) -> List[Message]:
         current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
             input_messages, agent_state, self.message_manager, self.actor
         )

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/agents/voice_agent.py

@@ -97,13 +97,12 @@ class VoiceAgent(BaseAgent):
             summarizer_agent=VoiceSleeptimeAgent(
                 agent_id=voice_sleeptime_agent_id,
                 convo_agent_state=agent_state,
-                openai_client=self.openai_client,
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 actor=self.actor,
                 block_manager=self.block_manager,
+                passage_manager=self.passage_manager,
                 target_block_label=self.summary_block_label,
-                message_transcripts=[],
             ),
             message_buffer_limit=agent_state.multi_agent_group.max_message_buffer_length,
             message_buffer_min=agent_state.multi_agent_group.min_message_buffer_length,

letta_nightly-0.7.9.dev20250502222710/letta/agents/voice_sleeptime_agent.py

@@ -0,0 +1,154 @@
+from typing import AsyncGenerator, List, Tuple, Union
+
+from letta.agents.helpers import _create_letta_response, serialize_message_history
+from letta.agents.letta_agent import LettaAgent
+from letta.orm.enums import ToolType
+from letta.schemas.agent import AgentState
+from letta.schemas.block import BlockUpdate
+from letta.schemas.enums import MessageStreamStatus
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.message import MessageCreate
+from letta.schemas.tool_rule import ChildToolRule, ContinueToolRule, InitToolRule, TerminalToolRule
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+from letta.services.summarizer.enums import SummarizationMode
+from letta.services.summarizer.summarizer import Summarizer
+from letta.tracing import trace_method
+
+
+class VoiceSleeptimeAgent(LettaAgent):
+    """
+    A special variant of the LettaAgent that helps with offline memory computations specifically for voice.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        convo_agent_state: AgentState,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        passage_manager: PassageManager,
+        target_block_label: str,
+        actor: User,
+    ):
+        super().__init__(
+            agent_id=agent_id,
+            message_manager=message_manager,
+            agent_manager=agent_manager,
+            block_manager=block_manager,
+            passage_manager=passage_manager,
+            actor=actor,
+        )
+
+        self.convo_agent_state = convo_agent_state
+        self.target_block_label = target_block_label
+        self.message_transcripts = []
+        self.summarizer = Summarizer(
+            mode=SummarizationMode.STATIC_MESSAGE_BUFFER,
+            summarizer_agent=None,
+            message_buffer_limit=20,
+            message_buffer_min=10,
+        )
+
+    def update_message_transcript(self, message_transcripts: List[str]):
+        self.message_transcripts = message_transcripts
+
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 20) -> LettaResponse:
+        """
+        Process the user's input message, allowing the model to call memory-related tools
+        until it decides to stop and provide a final response.
+        """
+        agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+
+        # Add tool rules to the agent_state specifically for this type of agent
+        agent_state.tool_rules = [
+            InitToolRule(tool_name="store_memories"),
+            ChildToolRule(tool_name="store_memories", children=["rethink_user_memory"]),
+            ContinueToolRule(tool_name="rethink_user_memory"),
+            TerminalToolRule(tool_name="finish_rethinking_memory"),
+        ]
+
+        # Summarize
+        current_in_context_messages, new_in_context_messages = await super()._step(
+            agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
+        )
+        new_in_context_messages, updated = self.summarizer.summarize(
+            in_context_messages=current_in_context_messages, new_letta_messages=new_in_context_messages
+        )
+        self.agent_manager.set_in_context_messages(
+            agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
+        )
+
+        return _create_letta_response(new_in_context_messages=new_in_context_messages, use_assistant_message=self.use_assistant_message)
+
+    @trace_method
+    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
+        """
+        Executes a tool and returns (result, success_flag).
+        """
+        # Special memory case
+        target_tool = next((x for x in agent_state.tools if x.name == tool_name), None)
+        if not target_tool:
+            return f"Tool not found: {tool_name}", False
+
+        try:
+            if target_tool.name == "rethink_user_memory" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
+                return self.rethink_user_memory(agent_state=agent_state, **tool_args)
+            elif target_tool.name == "finish_rethinking_memory" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
+                return "", True
+            elif target_tool.name == "store_memories" and target_tool.tool_type == ToolType.LETTA_VOICE_SLEEPTIME_CORE:
+                chunks = tool_args.get("chunks", [])
+                results = [self.store_memory(agent_state=self.convo_agent_state, **chunk_args) for chunk_args in chunks]
+
+                aggregated_result = next((res for res, _ in results if res is not None), None)
+                aggregated_success = all(success for _, success in results)
+
+                return aggregated_result, aggregated_success  # Note that here we store to the convo agent's archival memory
+            else:
+                result = f"Voice sleeptime agent tried invoking invalid tool with type {target_tool.tool_type}: {target_tool}"
+                return result, False
+        except Exception as e:
+            return f"Failed to call tool. Error: {e}", False
+
+    def rethink_user_memory(self, new_memory: str, agent_state: AgentState) -> Tuple[str, bool]:
+        if agent_state.memory.get_block(self.target_block_label) is None:
+            agent_state.memory.create_block(label=self.target_block_label, value=new_memory)
+
+        agent_state.memory.update_block_value(label=self.target_block_label, value=new_memory)
+
+        target_block = agent_state.memory.get_block(self.target_block_label)
+        self.block_manager.update_block(block_id=target_block.id, block_update=BlockUpdate(value=target_block.value), actor=self.actor)
+
+        return "", True
+
+    def store_memory(self, start_index: int, end_index: int, context: str, agent_state: AgentState) -> Tuple[str, bool]:
+        """
+        Store a memory.
+        """
+        try:
+            messages = self.message_transcripts[start_index : end_index + 1]
+            memory = serialize_message_history(messages, context)
+            self.agent_manager.passage_manager.insert_passage(
+                agent_state=agent_state,
+                agent_id=agent_state.id,
+                text=memory,
+                actor=self.actor,
+            )
+            self.agent_manager.rebuild_system_prompt(agent_id=agent_state.id, actor=self.actor, force=True)
+
+            return "", True
+        except Exception as e:
+            return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}", False
+
+    async def step_stream(
+        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = False
+    ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
+        """
+        This agent is synchronous-only. If called in an async context, raise an error.
+        """
+        raise NotImplementedError("VoiceSleeptimeAgent does not support async step.")

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/functions/function_sets/multi_agent.py

@@ -68,7 +68,7 @@ def send_message_to_agent_async(self: "Agent", message: str, other_agent_id: str
         messages=messages,
         other_agent_id=other_agent_id,
         log_prefix="[send_message_to_agent_async]",
-        use_retries=False,  # or True if you want to use async_send_message_with_retries
+        use_retries=False,  # or True if you want to use _async_send_message_with_retries
     )
 
     # Immediately return to caller

letta_nightly-0.7.9.dev20250502222710/letta/functions/function_sets/voice.py

@@ -0,0 +1,80 @@
+## Voice chat + sleeptime tools
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+def rethink_user_memory(agent_state: "AgentState", new_memory: str) -> None:
+    """
+    Rewrite memory block for the main agent, new_memory should contain all current information from the block that is not outdated or inconsistent, integrating any new information, resulting in a new memory block that is organized, readable, and comprehensive.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block. If there is no new information, then this should be the same as the content in the source block.
+
+    Returns:
+        None: None is always returned as this function does not produce a response.
+    """
+    # This is implemented directly in the agent loop
+    return None
+
+
+def finish_rethinking_memory(agent_state: "AgentState") -> None:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    return None
+
+
+class MemoryChunk(BaseModel):
+    start_index: int = Field(
+        ...,
+        description="Zero-based index of the first evicted line in this chunk.",
+    )
+    end_index: int = Field(
+        ...,
+        description="Zero-based index of the last evicted line (inclusive).",
+    )
+    context: str = Field(
+        ...,
+        description="1-3 sentence paraphrase capturing key facts/details, user preferences, or goals that this chunk reveals—written for future retrieval.",
+    )
+
+
+def store_memories(agent_state: "AgentState", chunks: List[MemoryChunk]) -> None:
+    """
+    Persist dialogue that is about to fall out of the agent’s context window.
+
+    Args:
+        chunks (List[MemoryChunk]):
+            Each chunk pinpoints a contiguous block of **evicted** lines and provides a short, forward-looking synopsis (`context`) that will be embedded for future semantic lookup.
+
+    Returns:
+        None
+    """
+    # This is implemented directly in the agent loop
+    return None
+
+
+def search_memory(
+    agent_state: "AgentState",
+    convo_keyword_queries: Optional[List[str]],
+    start_minutes_ago: Optional[int],
+    end_minutes_ago: Optional[int],
+) -> Optional[str]:
+    """
+    Look in long-term or earlier-conversation memory only when the user asks about something missing from the visible context. The user’s latest utterance is sent automatically as the main query.
+
+    Args:
+        convo_keyword_queries (Optional[List[str]]): Extra keywords (e.g., order ID, place name). Use *null* if not appropriate for the latest user message.
+        start_minutes_ago (Optional[int]): Newer bound of the time window for results, specified in minutes ago. Use *null* if no lower time bound is needed.
+        end_minutes_ago (Optional[int]): Older bound of the time window, in minutes ago. Use *null* if no upper bound is needed.
+
+    Returns:
+        Optional[str]: A formatted string of matching memory entries, or None if no
+            relevant memories are found.
+    """
+    # This is implemented directly in the agent loop
+    return None

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/functions/helpers.py

@@ -231,7 +231,7 @@ async def async_execute_send_message_to_agent(
     """
     Async helper to:
       1) validate the target agent exists & is in the same org,
-      2) send a message via async_send_message_with_retries.
+      2) send a message via _async_send_message_with_retries.
     """
     server = get_letta_server()
 
@@ -242,7 +242,7 @@ async def async_execute_send_message_to_agent(
         raise ValueError(f"Target agent {other_agent_id} either does not exist or is not in org " f"({sender_agent.user.organization_id}).")
 
     # 2. Use your async retry logic
-    return await async_send_message_with_retries(
+    return await _async_send_message_with_retries(
         server=server,
         sender_agent=sender_agent,
         target_agent_id=other_agent_id,
@@ -304,7 +304,7 @@ async def _async_send_message_with_retries(
     timeout: int,
     logging_prefix: Optional[str] = None,
 ) -> str:
-    logging_prefix = logging_prefix or "[async_send_message_with_retries]"
+    logging_prefix = logging_prefix or "[_async_send_message_with_retries]"
 
     for attempt in range(1, max_retries + 1):
         try:
@@ -363,7 +363,7 @@ def fire_and_forget_send_to_agent(
         messages (List[MessageCreate]): The messages to send.
         other_agent_id (str): The ID of the target agent.
         log_prefix (str): Prefix for logging.
-        use_retries (bool): If True, uses async_send_message_with_retries;
+        use_retries (bool): If True, uses _async_send_message_with_retries;
                             if False, calls server.send_message_to_agent directly.
     """
     server = get_letta_server()
@@ -381,7 +381,7 @@ def fire_and_forget_send_to_agent(
     async def background_task():
         try:
             if use_retries:
-                result = await async_send_message_with_retries(
+                result = await _async_send_message_with_retries(
                     server=server,
                     sender_agent=sender_agent,
                     target_agent_id=other_agent_id,
@@ -434,7 +434,7 @@ async def _send_message_to_agents_matching_tags_async(
     sender_agent: "Agent", server: "SyncServer", messages: List[MessageCreate], matching_agents: List["AgentState"]
 ) -> List[str]:
     async def _send_single(agent_state):
-        return await async_send_message_with_retries(
+        return await _async_send_message_with_retries(
             server=server,
             sender_agent=sender_agent,
             target_agent_id=agent_state.id,
@@ -475,7 +475,7 @@ async def _send_message_to_all_agents_in_group_async(sender_agent: "Agent", mess
 
     async def _send_single(agent_state):
         async with sem:
-            return await async_send_message_with_retries(
+            return await _async_send_message_with_retries(
                 server=server,
                 sender_agent=sender_agent,
                 target_agent_id=agent_state.id,

{letta_nightly-0.7.8.dev20250502104219 → letta_nightly-0.7.9.dev20250502222710}/letta/helpers/datetime_helpers.py

@@ -1,4 +1,5 @@
 import re
+import time
 from datetime import datetime, timedelta, timezone
 from time import strftime
 
@@ -77,6 +78,11 @@ def get_utc_time_int() -> int:
     return int(get_utc_time().timestamp())
 
 
+def get_utc_timestamp_ns() -> int:
+    """Get the current UTC time in nanoseconds"""
+    return int(time.time_ns())
+
+
 def timestamp_to_datetime(timestamp_seconds: int) -> datetime:
     """Convert Unix timestamp in seconds to UTC datetime object"""
     return datetime.fromtimestamp(timestamp_seconds, tz=timezone.utc)