letta-nightly 0.7.8.dev20250501104226__py3-none-any.whl → 0.7.9.dev20250502222710__py3-none-any.whl

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/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/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/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/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,