letta-nightly 0.7.15.dev20250514104255__py3-none-any.whl → 0.7.16.dev20250515205957__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -179,6 +179,15 @@ class Agent(BaseAgent):
                     raise ValueError(f"Invalid JSON format in message: {text_content}")
         return None
 
+    def ensure_read_only_block_not_modified(self, new_memory: Memory) -> None:
+        """
+        Throw an error if a read-only block has been modified
+        """
+        for label in self.agent_state.memory.list_block_labels():
+            if self.agent_state.memory.get_block(label).read_only:
+                if new_memory.get_block(label).value != self.agent_state.memory.get_block(label).value:
+                    raise ValueError(READ_ONLY_BLOCK_EDIT_ERROR)
+
     def update_memory_if_changed(self, new_memory: Memory) -> bool:
         """
         Update internal memory object and system prompt if there have been modifications.
@@ -1277,6 +1286,9 @@ class Agent(BaseAgent):
                 agent_state_copy = self.agent_state.__deepcopy__()
                 function_args["agent_state"] = agent_state_copy  # need to attach self to arg since it's dynamically linked
                 function_response = callable_func(**function_args)
+                self.ensure_read_only_block_not_modified(
+                    new_memory=agent_state_copy.memory
+                )  # memory editing tools cannot edit read-only blocks
                 self.update_memory_if_changed(agent_state_copy.memory)
             elif target_letta_tool.tool_type == ToolType.EXTERNAL_COMPOSIO:
                 action_name = generate_composio_action_from_func_name(target_letta_tool.name)

letta/agents/helpers.py

@@ -10,14 +10,18 @@ from letta.server.rest_api.utils import create_input_messages
 from letta.services.message_manager import MessageManager
 
 
-def _create_letta_response(new_in_context_messages: list[Message], use_assistant_message: bool) -> LettaResponse:
+def _create_letta_response(
+    new_in_context_messages: list[Message], use_assistant_message: bool, usage: LettaUsageStatistics
+) -> LettaResponse:
     """
     Converts the newly created/persisted messages into a LettaResponse.
     """
-    response_messages = []
-    for msg in new_in_context_messages:
-        response_messages.extend(msg.to_letta_messages(use_assistant_message=use_assistant_message))
-    return LettaResponse(messages=response_messages, usage=LettaUsageStatistics())
+    # NOTE: hacky solution to avoid returning heartbeat messages and the original user message
+    filter_user_messages = [m for m in new_in_context_messages if m.role != "user"]
+    response_messages = Message.to_letta_messages_from_list(
+        messages=filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
+    )
+    return LettaResponse(messages=response_messages, usage=usage)
 
 
 def _prepare_in_context_messages(
@@ -56,6 +60,45 @@ def _prepare_in_context_messages(
     return current_in_context_messages, new_in_context_messages
 
 
+async def _prepare_in_context_messages_async(
+    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.
+    Async version of _prepare_in_context_messages.
+
+    Args:
+        input_messages (List[MessageCreate]): The new user input messages to process.
+        agent_state (AgentState): The current state of the agent, including message buffer config.
+        message_manager (MessageManager): The manager used to retrieve and create messages.
+        actor (User): The user performing the action, used for access control and attribution.
+
+    Returns:
+        Tuple[List[Message], List[Message]]: A tuple containing:
+            - The current in-context messages (existing context for the agent).
+            - The new in-context messages (messages created from the new input).
+    """
+
+    if agent_state.message_buffer_autoclear:
+        # If autoclear is enabled, only include the most recent system message (usually at index 0)
+        current_in_context_messages = [
+            (await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor))[0]
+        ]
+    else:
+        # Otherwise, include the full list of messages by ID for context
+        current_in_context_messages = await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor)
+
+    # Create a new user message from the input and store it
+    new_in_context_messages = await message_manager.create_many_messages_async(
+        create_input_messages(input_messages=input_messages, agent_id=agent_state.id, actor=actor), actor=actor
+    )
+
+    return current_in_context_messages, new_in_context_messages
+
+
 def serialize_message_history(messages: List[str], context: str) -> str:
     """
     Produce an XML document like:

letta/agents/letta_agent.py

@@ -4,6 +4,7 @@ import uuid
 from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple, Union
 
 from openai import AsyncStream
+from openai.types import CompletionUsage
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 
 from letta.agents.base_agent import BaseAgent
@@ -23,6 +24,7 @@ from letta.schemas.letta_message_content import OmittedReasoningContent, Reasoni
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall
+from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_letta_messages_from_llm_response
 from letta.services.agent_manager import AgentManager
@@ -47,7 +49,6 @@ class LettaAgent(BaseAgent):
         block_manager: BlockManager,
         passage_manager: PassageManager,
         actor: User,
-        use_assistant_message: bool = True,
     ):
         super().__init__(agent_id=agent_id, openai_client=None, message_manager=message_manager, agent_manager=agent_manager, actor=actor)
 
@@ -55,26 +56,31 @@ class LettaAgent(BaseAgent):
         # Summarizer settings
         self.block_manager = block_manager
         self.passage_manager = passage_manager
-        self.use_assistant_message = use_assistant_message
         self.response_messages: List[Message] = []
 
-        self.last_function_response = self._load_last_function_response()
+        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)
 
     @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(
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True) -> LettaResponse:
+        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, usage = 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)
+        return _create_letta_response(
+            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+        )
 
     async def _step(
         self, agent_state: AgentState, input_messages: List[MessageCreate], max_steps: int = 10
-    ) -> Tuple[List[Message], List[Message]]:
+    ) -> Tuple[List[Message], List[Message], CompletionUsage]:
         current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
             input_messages, agent_state, self.message_manager, self.actor
         )
@@ -84,6 +90,7 @@ class LettaAgent(BaseAgent):
             put_inner_thoughts_first=True,
             actor=self.actor,
         )
+        usage = LettaUsageStatistics()
         for _ in range(max_steps):
             response = await self._get_ai_reply(
                 llm_client=llm_client,
@@ -95,11 +102,21 @@ class LettaAgent(BaseAgent):
             )
 
             tool_call = response.choices[0].message.tool_calls[0]
+            reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
 
-            persisted_messages, should_continue = await self._handle_ai_response(tool_call, agent_state, tool_rules_solver)
+            persisted_messages, should_continue = await self._handle_ai_response(
+                tool_call, agent_state, tool_rules_solver, reasoning_content=reasoning
+            )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
 
+            # update usage
+            # TODO: add run_id
+            usage.step_count += 1
+            usage.completion_tokens += response.usage.completion_tokens
+            usage.prompt_tokens += response.usage.prompt_tokens
+            usage.total_tokens += response.usage.total_tokens
+
             if not should_continue:
                 break
 
@@ -108,17 +125,17 @@ 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 current_in_context_messages, new_in_context_messages
+        return current_in_context_messages, new_in_context_messages, usage
 
     @trace_method
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = False
+        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True
     ) -> 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 = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+        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(
             input_messages, agent_state, self.message_manager, self.actor
         )
@@ -128,6 +145,7 @@ class LettaAgent(BaseAgent):
             put_inner_thoughts_first=True,
             actor=self.actor,
         )
+        usage = LettaUsageStatistics()
 
         for _ in range(max_steps):
             stream = await self._get_ai_reply(
@@ -137,7 +155,6 @@ class LettaAgent(BaseAgent):
                 tool_rules_solver=tool_rules_solver,
                 stream=True,
             )
-
             # TODO: THIS IS INCREDIBLY UGLY
             # TODO: THERE ARE MULTIPLE COPIES OF THE LLM_CONFIG EVERYWHERE THAT ARE GETTING MANIPULATED
             interface = AnthropicStreamingInterface(
@@ -146,6 +163,12 @@ class LettaAgent(BaseAgent):
             async for chunk in interface.process(stream):
                 yield f"data: {chunk.model_dump_json()}\n\n"
 
+            # update usage
+            usage.step_count += 1
+            usage.completion_tokens += interface.output_tokens
+            usage.prompt_tokens += interface.input_tokens
+            usage.total_tokens += interface.input_tokens + interface.output_tokens
+
             # Process resulting stream content
             tool_call = interface.get_tool_call_object()
             reasoning_content = interface.get_reasoning_content()
@@ -160,6 +183,10 @@ class LettaAgent(BaseAgent):
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
 
+            if not use_assistant_message or should_continue:
+                tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
+                yield f"data: {tool_return.model_dump_json()}\n\n"
+
             if not should_continue:
                 break
 
@@ -174,7 +201,7 @@ class LettaAgent(BaseAgent):
         self.num_archival_memories = self.passage_manager.size(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"
         yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
 
     @trace_method
@@ -214,6 +241,8 @@ class LettaAgent(BaseAgent):
         ]
 
         # Mirror the sync agent loop: get allowed tools or allow all if none are allowed
+        if self.last_function_response is None:
+            self.last_function_response = await self._load_last_function_response_async()
         valid_tool_names = tool_rules_solver.get_allowed_tool_names(
             available_tools=set([t.name for t in tools]),
             last_function_response=self.last_function_response,
@@ -307,7 +336,7 @@ class LettaAgent(BaseAgent):
             pre_computed_assistant_message_id=pre_computed_assistant_message_id,
             pre_computed_tool_message_id=pre_computed_tool_message_id,
         )
-        persisted_messages = self.message_manager.create_many_messages(tool_call_messages, actor=self.actor)
+        persisted_messages = await self.message_manager.create_many_messages_async(tool_call_messages, actor=self.actor)
         self.last_function_response = function_response
 
         return persisted_messages, continue_stepping
@@ -359,7 +388,6 @@ class LettaAgent(BaseAgent):
                     block_manager=self.block_manager,
                     passage_manager=self.passage_manager,
                     actor=self.actor,
-                    use_assistant_message=True,
                 )
 
                 augmented_message = (
@@ -394,9 +422,9 @@ class LettaAgent(BaseAgent):
         results = await asyncio.gather(*tasks)
         return results
 
-    def _load_last_function_response(self):
+    async def _load_last_function_response_async(self):
         """Load the last function response from message history"""
-        in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_id, actor=self.actor)
+        in_context_messages = await self.agent_manager.get_in_context_messages_async(agent_id=self.agent_id, actor=self.actor)
         for msg in reversed(in_context_messages):
             if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and isinstance(msg.content[0], TextContent):
                 text_content = msg.content[0].text

letta/agents/letta_agent_batch.py

@@ -7,7 +7,7 @@ from aiomultiprocess import Pool
 from anthropic.types.beta.messages import BetaMessageBatchCanceledResult, BetaMessageBatchErroredResult, BetaMessageBatchSucceededResult
 
 from letta.agents.base_agent import BaseAgent
-from letta.agents.helpers import _prepare_in_context_messages
+from letta.agents.helpers import _prepare_in_context_messages_async
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import enable_strict_mode
@@ -107,7 +107,6 @@ class LettaAgentBatch(BaseAgent):
         sandbox_config_manager: SandboxConfigManager,
         job_manager: JobManager,
         actor: User,
-        use_assistant_message: bool = True,
         max_steps: int = 10,
     ):
         self.message_manager = message_manager
@@ -117,7 +116,6 @@ class LettaAgentBatch(BaseAgent):
         self.batch_manager = batch_manager
         self.sandbox_config_manager = sandbox_config_manager
         self.job_manager = job_manager
-        self.use_assistant_message = use_assistant_message
         self.actor = actor
         self.max_steps = max_steps
 
@@ -128,6 +126,7 @@ class LettaAgentBatch(BaseAgent):
         letta_batch_job_id: str,
         agent_step_state_mapping: Optional[Dict[str, AgentStepState]] = None,
     ) -> LettaBatchResponse:
+        """Carry out agent steps until the LLM request is sent."""
         log_event(name="validate_inputs")
         if not batch_requests:
             raise ValueError("Empty list of batch_requests passed in!")
@@ -135,15 +134,26 @@ class LettaAgentBatch(BaseAgent):
             agent_step_state_mapping = {}
 
         log_event(name="load_and_prepare_agents")
-        agent_messages_mapping: Dict[str, List[Message]] = {}
-        agent_tools_mapping: Dict[str, List[dict]] = {}
+        # prepares (1) agent states, (2) step states, (3) LLMBatchItems (4) message batch_item_ids (5) messages per agent (6) tools per agent
+
+        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_batch_item_mapping: dict[str, LLMBatchItem] = {}
+
+        # fetch agent states in batch
+        agent_mapping = {
+            agent_state.id: agent_state
+            for agent_state in await self.agent_manager.get_agents_by_ids_async(
+                agent_ids=[request.agent_id for request in batch_requests], actor=self.actor
+            )
+        }
+
         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_state = agent_mapping[agent_id]
+            agent_states.append(agent_state)  # keeping this to maintain ordering, but may not be necessary
 
             if agent_id not in agent_step_state_mapping:
                 agent_step_state_mapping[agent_id] = AgentStepState(
@@ -164,7 +174,7 @@ class LettaAgentBatch(BaseAgent):
             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_messages_mapping[agent_id] = await self._prepare_in_context_messages_per_agent_async(
                 agent_state=agent_state, input_messages=batch_request.messages
             )
 
@@ -186,7 +196,7 @@ class LettaAgentBatch(BaseAgent):
         )
 
         log_event(name="persist_llm_batch_job")
-        llm_batch_job = self.batch_manager.create_llm_batch_job(
+        llm_batch_job = await self.batch_manager.create_llm_batch_job_async(
             llm_provider=ProviderType.anthropic,  # TODO: Expand to more providers
             create_batch_response=batch_response,
             actor=self.actor,
@@ -204,7 +214,7 @@ class LettaAgentBatch(BaseAgent):
 
         if batch_items:
             log_event(name="bulk_create_batch_items")
-            batch_items_persisted = self.batch_manager.create_llm_batch_items_bulk(batch_items, actor=self.actor)
+            batch_items_persisted = await self.batch_manager.create_llm_batch_items_bulk_async(batch_items, actor=self.actor)
 
         log_event(name="return_batch_response")
         return LettaBatchResponse(
@@ -219,7 +229,7 @@ class LettaAgentBatch(BaseAgent):
     @trace_method
     async def resume_step_after_request(self, letta_batch_id: str, llm_batch_id: str) -> LettaBatchResponse:
         log_event(name="load_context")
-        llm_batch_job = self.batch_manager.get_llm_batch_job_by_id(llm_batch_id=llm_batch_id, actor=self.actor)
+        llm_batch_job = await self.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=llm_batch_id, actor=self.actor)
         ctx = await self._collect_resume_context(llm_batch_id)
 
         log_event(name="update_statuses")
@@ -229,7 +239,7 @@ class LettaAgentBatch(BaseAgent):
         exec_results = await self._execute_tools(ctx)
 
         log_event(name="persist_messages")
-        msg_map = self._persist_tool_messages(exec_results, ctx)
+        msg_map = await self._persist_tool_messages(exec_results, ctx)
 
         log_event(name="mark_steps_done")
         self._mark_steps_complete(llm_batch_id, ctx.agent_ids)
@@ -237,7 +247,9 @@ class LettaAgentBatch(BaseAgent):
         log_event(name="prepare_next")
         next_reqs, next_step_state = self._prepare_next_iteration(exec_results, ctx, msg_map)
         if len(next_reqs) == 0:
-            self.job_manager.update_job_by_id(job_id=letta_batch_id, job_update=JobUpdate(status=JobStatus.completed), actor=self.actor)
+            await self.job_manager.update_job_by_id_async(
+                job_id=letta_batch_id, job_update=JobUpdate(status=JobStatus.completed), actor=self.actor
+            )
             return LettaBatchResponse(
                 letta_batch_id=llm_batch_job.letta_batch_job_id,
                 last_llm_batch_id=llm_batch_job.id,
@@ -256,18 +268,22 @@ class LettaAgentBatch(BaseAgent):
     @trace_method
     async def _collect_resume_context(self, llm_batch_id: str) -> _ResumeContext:
         # NOTE: We only continue for items with successful results
-        batch_items = self.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_id, request_status=JobStatus.completed)
+        batch_items = await self.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_id, request_status=JobStatus.completed)
 
-        agent_ids, agent_state_map = [], {}
-        provider_results, name_map, args_map, cont_map = {}, {}, {}, {}
+        agent_ids = []
+        provider_results = {}
         request_status_updates: List[RequestStatusUpdateInfo] = []
 
         for item in batch_items:
             aid = item.agent_id
             agent_ids.append(aid)
-            agent_state_map[aid] = self.agent_manager.get_agent_by_id(aid, actor=self.actor)
             provider_results[aid] = item.batch_request_result.result
 
+        agent_states = await self.agent_manager.get_agents_by_ids_async(agent_ids, actor=self.actor)
+        agent_state_map = {agent.id: agent for agent in agent_states}
+
+        name_map, args_map, cont_map = {}, {}, {}
+        for aid in agent_ids:
             # status bookkeeping
             pr = provider_results[aid]
             status = (
@@ -344,14 +360,14 @@ class LettaAgentBatch(BaseAgent):
                 tool_params.append(param)
 
         if rethink_memory_params:
-            return self._bulk_rethink_memory(rethink_memory_params)
+            return await self._bulk_rethink_memory_async(rethink_memory_params)
 
         if tool_params:
             async with Pool() as pool:
                 return await pool.map(execute_tool_wrapper, tool_params)
 
     @trace_method
-    def _bulk_rethink_memory(self, params: List[ToolExecutionParams]) -> Sequence[Tuple[str, Tuple[str, bool]]]:
+    async def _bulk_rethink_memory_async(self, params: List[ToolExecutionParams]) -> Sequence[Tuple[str, Tuple[str, bool]]]:
         updates = {}
         result = []
         for param in params:
@@ -372,11 +388,11 @@ class LettaAgentBatch(BaseAgent):
             # TODO: This is quite ugly and confusing - this is mostly to align with the returns of other tools
             result.append((param.agent_id, ("", True)))
 
-        self.block_manager.bulk_update_block_values(updates=updates, actor=self.actor)
+        await self.block_manager.bulk_update_block_values_async(updates=updates, actor=self.actor)
 
         return result
 
-    def _persist_tool_messages(
+    async def _persist_tool_messages(
         self,
         exec_results: Sequence[Tuple[str, Tuple[str, bool]]],
         ctx: _ResumeContext,
@@ -398,7 +414,7 @@ class LettaAgentBatch(BaseAgent):
             )
             msg_map[aid] = msgs
         # flatten & persist
-        self.message_manager.create_many_messages([m for msgs in msg_map.values() for m in msgs], actor=self.actor)
+        await self.message_manager.create_many_messages_async([m for msgs in msg_map.values() for m in msgs], actor=self.actor)
         return msg_map
 
     def _mark_steps_complete(self, llm_batch_id: str, agent_ids: List[str]) -> None:
@@ -530,12 +546,14 @@ class LettaAgentBatch(BaseAgent):
         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 _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(
+    async def _prepare_in_context_messages_per_agent_async(
+        self, agent_state: AgentState, input_messages: List[MessageCreate]
+    ) -> List[Message]:
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
 
-        in_context_messages = self._rebuild_memory(current_in_context_messages + new_in_context_messages, agent_state)
+        in_context_messages = await self._rebuild_memory_async(current_in_context_messages + new_in_context_messages, agent_state)
         return in_context_messages
 
     # TODO: Make this a bullk function

letta/agents/voice_sleeptime_agent.py

@@ -58,7 +58,7 @@ class VoiceSleeptimeAgent(LettaAgent):
     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:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 20, use_assistant_message: bool = True) -> 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.
@@ -74,7 +74,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         ]
 
         # Summarize
-        current_in_context_messages, new_in_context_messages = await super()._step(
+        current_in_context_messages, new_in_context_messages, usage = await super()._step(
             agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
         )
         new_in_context_messages, updated = self.summarizer.summarize(
@@ -84,7 +84,9 @@ class VoiceSleeptimeAgent(LettaAgent):
             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)
+        return _create_letta_response(
+            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+        )
 
     @trace_method
     async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
@@ -146,7 +148,7 @@ class VoiceSleeptimeAgent(LettaAgent):
             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
+        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
         This agent is synchronous-only. If called in an async context, raise an error.

letta/client/client.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import sys
 import time
@@ -3055,7 +3056,21 @@ class LocalClient(AbstractClient):
         Returns:
             tools (List[Tool]): List of tools
         """
-        return self.server.tool_manager.list_tools(after=after, limit=limit, actor=self.user)
+        # Get the current event loop or create a new one if there isn't one
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We're in an async context but can't await - use a new loop via run_coroutine_threadsafe
+                concurrent_future = asyncio.run_coroutine_threadsafe(
+                    self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit), loop
+                )
+                return concurrent_future.result()
+            else:
+                # We have a loop but it's not running - we can just run the coroutine
+                return loop.run_until_complete(self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit))
+        except RuntimeError:
+            # No running event loop - create a new one with asyncio.run
+            return asyncio.run(self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit))
 
     def get_tool(self, id: str) -> Optional[Tool]:
         """

letta/constants.py

@@ -195,6 +195,9 @@ DATA_SOURCE_ATTACH_ALERT = (
     "[ALERT] New data was just uploaded to archival memory. You can view this data by calling the archival_memory_search tool."
 )
 
+# Throw an error message when a read-only block is edited
+READ_ONLY_BLOCK_EDIT_ERROR = f"{ERROR_MESSAGE_PREFIX} This block is read-only and cannot be edited."
+
 # The ackknowledgement message used in the summarize sequence
 MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the message (and only the summary, nothing else) once I receive the conversation history. I'm ready."
 

letta/functions/async_composio_toolset.py

@@ -12,7 +12,7 @@ from composio.exceptions import (
 )
 
 
-class AsyncComposioToolSet(BaseComposioToolSet, runtime="letta"):
+class AsyncComposioToolSet(BaseComposioToolSet, runtime="letta", description_char_limit=1024):
     """
     Async version of ComposioToolSet client for interacting with Composio API
     Used to asynchronously hit the execute action endpoint

letta/groups/sleeptime_multi_agent.py

@@ -42,6 +42,7 @@ class SleeptimeMultiAgent(Agent):
         self.group_manager = GroupManager()
         self.message_manager = MessageManager()
         self.job_manager = JobManager()
+        self.mcp_clients = mcp_clients
 
     def _run_async_in_new_thread(self, coro):
         """Run an async coroutine in a new thread with its own event loop"""