letta-nightly 0.6.48.dev20250407104216__tar.gz → 0.6.49.dev20250408030511__tar.gz

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.48.dev20250407104216
+Version: 0.6.49.dev20250408030511
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -49,7 +49,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.65,<0.2.0) ; extra == "desktop"
+Requires-Dist: letta_client (>=0.1.97,<0.2.0) ; extra == "desktop"
 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.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/__init__.py

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

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/agent.py

@@ -52,7 +52,11 @@ from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import check_supports_structured_output, compile_memory_metadata_block
+from letta.services.helpers.agent_manager_helper import (
+    check_supports_structured_output,
+    compile_memory_metadata_block,
+    compile_system_message,
+)
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
@@ -130,6 +134,7 @@ class Agent(BaseAgent):
         # Different interfaces can handle events differently
         # e.g., print in CLI vs send a discord message with a discord bot
         self.interface = interface
+        self.chunk_index = 0
 
         # Create the persistence manager object based on the AgentState info
         self.message_manager = MessageManager()
@@ -246,9 +251,11 @@ class Agent(BaseAgent):
             group_id=group_id,
         )
         messages.append(new_message)
-        self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message)
+        self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message, chunk_index=self.chunk_index)
+        self.chunk_index += 1
         if include_function_failed_message:
-            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=new_message)
+            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=new_message, chunk_index=self.chunk_index)
+            self.chunk_index += 1
 
         # Return updated messages
         return messages
@@ -295,11 +302,35 @@ class Agent(BaseAgent):
             and not self.supports_structured_output
             and len(self.tool_rules_solver.init_tool_rules) > 0
         ):
+            # TODO: This just seems wrong? What if there are more than 1 init tool rules?
             force_tool_call = self.tool_rules_solver.init_tool_rules[0].tool_name
         # Force a tool call if exactly one tool is specified
         elif step_count is not None and step_count > 0 and len(allowed_tool_names) == 1:
             force_tool_call = allowed_tool_names[0]
 
+        if force_tool_call == "core_memory_insert":
+            current_system_message = message_sequence[0]
+            new_memory = Memory(
+                blocks=self.agent_state.memory.blocks,
+                prompt_template=(
+                    "{% for block in blocks %}"
+                    '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
+                    "{% for line in block.value.splitlines() %}"
+                    "{{ loop.index0 }}: {{ line }}\n"
+                    "{% endfor %}"
+                    "</{{ block.label }}>"
+                    "{% if not loop.last %}\n{% endif %}"
+                    "{% endfor %}"
+                ),
+            )
+            new_system_message_str = compile_system_message(
+                system_prompt=self.agent_state.system,
+                in_context_memory=new_memory,
+                in_context_memory_last_edit=current_system_message.created_at,
+                previous_message_count=len(message_sequence),
+            )
+            message_sequence[0].content = [TextContent(text=new_system_message_str)]
+
         for attempt in range(1, empty_response_retry_limit + 1):
             try:
                 log_telemetry(self.logger, "_get_ai_reply create start")
@@ -313,9 +344,7 @@ class Agent(BaseAgent):
                     response = llm_client.send_llm_request(
                         messages=message_sequence,
                         tools=allowed_functions,
-                        tool_call=function_call,
                         stream=stream,
-                        first_message=first_message,
                         force_tool_call=force_tool_call,
                     )
                 else:
@@ -431,7 +460,8 @@ class Agent(BaseAgent):
             nonnull_content = False
             if response_message.content or response_message.reasoning_content or response_message.redacted_reasoning_content:
                 # The content if then internal monologue, not chat
-                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
+                self.chunk_index += 1
                 # Flag to avoid printing a duplicate if inner thoughts get popped from the function call
                 nonnull_content = True
 
@@ -480,7 +510,8 @@ class Agent(BaseAgent):
                 response_message.content = function_args.pop("inner_thoughts")
             # The content if then internal monologue, not chat
             if response_message.content and not nonnull_content:
-                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
+                self.chunk_index += 1
 
             # (Still parsing function args)
             # Handle requests for immediate heartbeat
@@ -502,7 +533,8 @@ class Agent(BaseAgent):
             # Failure case 3: function failed during execution
             # NOTE: the msg_obj associated with the "Running " message is the prior assistant message, not the function/tool role message
             #       this is because the function/tool role message is only created once the function/tool has executed/returned
-            self.interface.function_message(f"Running {function_name}({function_args})", msg_obj=messages[-1])
+            self.interface.function_message(f"Running {function_name}({function_args})", msg_obj=messages[-1], chunk_index=self.chunk_index)
+            self.chunk_index += 1
             try:
                 # handle tool execution (sandbox) and state updates
                 log_telemetry(
@@ -635,8 +667,10 @@ class Agent(BaseAgent):
                     group_id=group_id,
                 )
             )  # extend conversation with function response
-            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1])
-            self.interface.function_message(f"Success: {function_response_string}", msg_obj=messages[-1])
+            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1], chunk_index=self.chunk_index)
+            self.chunk_index += 1
+            self.interface.function_message(f"Success: {function_response_string}", msg_obj=messages[-1], chunk_index=self.chunk_index)
+            self.chunk_index += 1
             self.last_function_response = function_response
 
         else:
@@ -652,7 +686,8 @@ class Agent(BaseAgent):
                     group_id=group_id,
                 )
             )  # extend conversation with assistant's reply
-            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
+            self.chunk_index += 1
             heartbeat_request = False
             function_failed = False
 
@@ -1243,7 +1278,7 @@ class Agent(BaseAgent):
                 callable_func = get_function_from_module(LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name)
                 function_args["self"] = self  # need to attach self to arg since it's dynamically linked
                 function_response = callable_func(**function_args)
-            elif target_letta_tool.tool_type == ToolType.LETTA_MEMORY_CORE:
+            elif target_letta_tool.tool_type == ToolType.LETTA_MEMORY_CORE or target_letta_tool.tool_type == ToolType.LETTA_SLEEPTIME_CORE:
                 callable_func = get_function_from_module(LETTA_CORE_TOOL_MODULE_NAME, function_name)
                 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

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/agents/base_agent.py

@@ -1,9 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Optional
+from typing import Any, AsyncGenerator, Optional, Union
 
 import openai
 
-from letta.schemas.letta_message import UserMessage
+from letta.schemas.enums import MessageStreamStatus
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, UserMessage
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
@@ -39,9 +40,11 @@ class BaseAgent(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> AsyncGenerator[str, None]:
+    async def step_stream(
+        self, input_message: UserMessage, max_steps: int = 10
+    ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
-        Main async execution loop for the agent. Implementations must yield messages as SSE events.
+        Main streaming execution loop for the agent.
         """
         raise NotImplementedError
 

letta_nightly-0.6.49.dev20250408030511/letta/agents/helpers.py

@@ -0,0 +1,52 @@
+from typing import Dict, List, Tuple
+
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.message import Message
+from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
+from letta.server.rest_api.utils import create_user_message
+from letta.services.message_manager import MessageManager
+
+
+def _create_letta_response(new_in_context_messages: list[Message], use_assistant_message: bool) -> 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_message(use_assistant_message=use_assistant_message))
+    return LettaResponse(messages=response_messages, usage=LettaUsageStatistics())
+
+
+def _prepare_in_context_messages(
+    input_message: Dict, 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.
+
+    Args:
+        input_message (Dict): The new user input message 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 = [message_manager.get_messages_by_ids(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 = message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=actor)
+
+    # Create a new user message from the input and store it
+    new_in_context_messages = message_manager.create_many_messages(
+        [create_user_message(input_message=input_message, agent_id=agent_state.id, actor=actor)], actor=actor
+    )
+
+    return current_in_context_messages, new_in_context_messages

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/agents/letta_agent.py

@@ -1,27 +1,32 @@
 import asyncio
 import json
 import uuid
-from typing import Any, AsyncGenerator, Dict, List, Tuple
+from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple, Union
 
 from openai import AsyncStream
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 
 from letta.agents.base_agent import BaseAgent
-from letta.constants import DEFAULT_MESSAGE_TOOL
+from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import enable_strict_mode
+from letta.interfaces.anthropic_streaming_interface import AnthropicStreamingInterface
 from letta.llm_api.llm_client import LLMClient
+from letta.llm_api.llm_client_base import LLMClientBase
+from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
+from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import AssistantMessage
+from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.openai.chat_completion_request import UserMessage
-from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.openai.chat_completion_response import ToolCall
 from letta.schemas.user import User
-from letta.server.rest_api.utils import create_tool_call_messages_from_openai_response, create_user_message
+from letta.server.rest_api.utils import create_letta_messages_from_llm_response
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import compile_system_message
@@ -58,76 +63,130 @@ class LettaAgent(BaseAgent):
     async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
         input_message = self.pre_process_input_message(input_message)
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
-        # TODO: Extend to beyond just system message
-        system_message = [self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)[0]]
-        persisted_letta_messages = self.message_manager.create_many_messages(
-            [create_user_message(input_message=input_message, agent_id=agent_state.id, actor=self.actor)], actor=self.actor
+        current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
+            input_message, agent_state, self.message_manager, self.actor
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
-
-        # TODO: Note that we do absolutely 0 pulling in of in-context messages here
-        # TODO: This is specific to B, and needs to be changed
+        llm_client = LLMClient.create(
+            llm_config=agent_state.llm_config,
+            put_inner_thoughts_first=True,
+        )
         for step in range(max_steps):
             response = await self._get_ai_reply(
-                in_context_messages=system_message + persisted_letta_messages,
+                llm_client=llm_client,
+                in_context_messages=current_in_context_messages + new_in_context_messages,
                 agent_state=agent_state,
                 tool_rules_solver=tool_rules_solver,
+                stream=False,
             )
-            persisted_messages, should_continue = await self._handle_ai_response(response, agent_state, tool_rules_solver)
-            persisted_letta_messages.extend(persisted_messages)
+
+            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)
+            new_in_context_messages.extend(persisted_messages)
 
             if not should_continue:
                 break
 
-        # Persist messages
-        # Translate to letta response messages
-        response_messages = []
-        for message in persisted_letta_messages:
-            response_messages += message.to_letta_message(use_assistant_message=self.use_assistant_message)
+        # Extend the in context message ids
+        if not agent_state.message_buffer_autoclear:
+            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 LettaResponse(
-            messages=response_messages,
-            # TODO: Actually populate this
-            usage=LettaUsageStatistics(),
-        )
+        return _create_letta_response(new_in_context_messages=new_in_context_messages, use_assistant_message=self.use_assistant_message)
 
-    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> AsyncGenerator[str, None]:
+    @trace_method
+    async def step_stream(
+        self, input_message: UserMessage, max_steps: int = 10, use_assistant_message: bool = False
+    ) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
-        raise NotImplementedError("Not implemented for letta agent")
+        input_message = self.pre_process_input_message(input_message)
+        agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+        current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
+            input_message, agent_state, self.message_manager, self.actor
+        )
+        tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
+        llm_client = LLMClient.create(
+            llm_config=agent_state.llm_config,
+            put_inner_thoughts_first=True,
+        )
+
+        for step 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,
+                agent_state=agent_state,
+                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(
+                use_assistant_message=use_assistant_message, put_inner_thoughts_in_kwarg=llm_client.llm_config.put_inner_thoughts_in_kwargs
+            )
+            async for chunk in interface.process(stream):
+                yield f"data: {chunk.model_dump_json()}\n\n"
+
+            # Process resulting stream content
+            tool_call = interface.get_tool_call_object()
+            reasoning_content = interface.get_reasoning_content()
+            persisted_messages, should_continue = await self._handle_ai_response(
+                tool_call,
+                agent_state,
+                tool_rules_solver,
+                reasoning_content=reasoning_content,
+                pre_computed_assistant_message_id=interface.letta_assistant_message_id,
+                pre_computed_tool_message_id=interface.letta_tool_message_id,
+            )
+            new_in_context_messages.extend(persisted_messages)
+
+            if not should_continue:
+                break
+
+        # Extend the in context message ids
+        if not agent_state.message_buffer_autoclear:
+            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)
+
+        # TODO: Also yield out a letta usage stats SSE
+
+        yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
 
     @trace_method
     async def _get_ai_reply(
         self,
+        llm_client: LLMClientBase,
         in_context_messages: List[Message],
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
+        stream: bool,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
         in_context_messages = self._rebuild_memory(in_context_messages, agent_state)
 
         tools = [
             t
             for t in agent_state.tools
-            if t.tool_type in {ToolType.CUSTOM}
-            or (t.tool_type == ToolType.LETTA_CORE and t.name == DEFAULT_MESSAGE_TOOL)
+            if t.tool_type in {ToolType.CUSTOM, ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}
             or (t.tool_type == ToolType.LETTA_MULTI_AGENT_CORE and t.name == "send_message_to_agents_matching_tags")
         ]
 
-        valid_tool_names = set(tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools])))
-        allowed_tools = [enable_strict_mode(t.json_schema) for t in tools if t.name in valid_tool_names]
+        valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
+        # TODO: Copied from legacy agent loop, so please be cautious
+        # Set force tool
+        force_tool_call = None
+        if len(valid_tool_names) == 1:
+            force_tool_call = valid_tool_names[0]
 
-        llm_client = LLMClient.create(
-            llm_config=agent_state.llm_config,
-            put_inner_thoughts_first=True,
-        )
+        allowed_tools = [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
 
         response = await llm_client.send_llm_request_async(
             messages=in_context_messages,
             tools=allowed_tools,
-            tool_call=None,
-            stream=False,
+            force_tool_call=force_tool_call,
+            stream=stream,
         )
 
         return response
@@ -135,19 +194,18 @@ class LettaAgent(BaseAgent):
     @trace_method
     async def _handle_ai_response(
         self,
-        chat_completion_response: ChatCompletion,
+        tool_call: ToolCall,
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
+        reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
+        pre_computed_assistant_message_id: Optional[str] = None,
+        pre_computed_tool_message_id: Optional[str] = None,
     ) -> Tuple[List[Message], bool]:
         """
         Now that streaming is done, handle the final AI response.
         This might yield additional SSE tokens if we do stalling.
         At the end, set self._continue_execution accordingly.
         """
-        # TODO: Some key assumptions here.
-        # TODO: Assume every call has a tool call, i.e. tool_choice is REQUIRED
-        tool_call = chat_completion_response.choices[0].message.tool_calls[0]
-
         tool_call_name = tool_call.function.name
         tool_call_args_str = tool_call.function.arguments
 
@@ -158,6 +216,8 @@ class LettaAgent(BaseAgent):
 
         # Get request heartbeats and coerce to bool
         request_heartbeat = tool_args.pop("request_heartbeat", False)
+        # Pre-emptively pop out inner_thoughts
+        tool_args.pop(INNER_THOUGHTS_KWARG, "")
 
         # So this is necessary, because sometimes non-structured outputs makes mistakes
         if not isinstance(request_heartbeat, bool):
@@ -186,7 +246,7 @@ class LettaAgent(BaseAgent):
             continue_stepping = True
 
         # 5. Persist to DB
-        tool_call_messages = create_tool_call_messages_from_openai_response(
+        tool_call_messages = create_letta_messages_from_llm_response(
             agent_id=agent_state.id,
             model=agent_state.llm_config.model,
             function_name=tool_call_name,
@@ -196,6 +256,9 @@ class LettaAgent(BaseAgent):
             function_response=tool_result,
             actor=self.actor,
             add_heartbeat_request_system_message=continue_stepping,
+            reasoning_content=reasoning_content,
+            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)
 

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/agents/voice_agent.py

@@ -34,7 +34,7 @@ from letta.schemas.user import User
 from letta.server.rest_api.utils import (
     convert_letta_messages_to_openai,
     create_assistant_messages_from_openai_response,
-    create_tool_call_messages_from_openai_response,
+    create_letta_messages_from_llm_response,
     create_user_message,
 )
 from letta.services.agent_manager import AgentManager
@@ -207,7 +207,7 @@ class VoiceAgent(BaseAgent):
             in_memory_message_history.append(heartbeat_user_message.model_dump())
 
             # 5. Also store in DB
-            tool_call_messages = create_tool_call_messages_from_openai_response(
+            tool_call_messages = create_letta_messages_from_llm_response(
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
                 function_name=tool_call_name,

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/constants.py

@@ -52,10 +52,22 @@ DEFAULT_PRESET = "memgpt_chat"
 BASE_TOOLS = ["send_message", "conversation_search", "archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
+# Base tools if the memgpt agent has enable_sleeptime on
+BASE_SLEEPTIME_CHAT_TOOLS = ["send_message", "conversation_search", "archival_memory_search"]
+# Base memory tools for sleeptime agent
+BASE_SLEEPTIME_TOOLS = [
+    "rethink_memory",
+    "finish_rethinking_memory",
+    "view_core_memory_with_line_numbers",
+    "core_memory_insert",
+    "archival_memory_insert",
+    "archival_memory_search",
+    "conversation_search",
+]
 # Multi agent tools
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]
 # Set of all built-in Letta tools
-LETTA_TOOL_SET = set(BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS)
+LETTA_TOOL_SET = set(BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS)
 
 # 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_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/errors.py

@@ -1,6 +1,6 @@
 import json
 from enum import Enum
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
 # Avoid circular imports
 if TYPE_CHECKING:
@@ -10,6 +10,10 @@ if TYPE_CHECKING:
 class ErrorCode(Enum):
     """Enum for error codes used by client."""
 
+    NOT_FOUND = "NOT_FOUND"
+    UNAUTHENTICATED = "UNAUTHENTICATED"
+    PERMISSION_DENIED = "PERMISSION_DENIED"
+    INVALID_ARGUMENT = "INVALID_ARGUMENT"
     INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
     CONTEXT_WINDOW_EXCEEDED = "CONTEXT_WINDOW_EXCEEDED"
     RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
@@ -18,7 +22,9 @@ class ErrorCode(Enum):
 class LettaError(Exception):
     """Base class for all Letta related errors."""
 
-    def __init__(self, message: str, code: Optional[ErrorCode] = None, details: dict = {}):
+    def __init__(self, message: str, code: Optional[ErrorCode] = None, details: Optional[Union[Dict, str, object]] = None):
+        if details is None:
+            details = {}
         self.message = message
         self.code = code
         self.details = details
@@ -91,7 +97,8 @@ class LLMUnprocessableEntityError(LLMError):
 
 
 class LLMServerError(LLMError):
-    """Error when LLM service encounters an internal error"""
+    """Error indicating an internal server error occurred within the LLM service itself
+    while processing the request."""
 
 
 class BedrockPermissionError(LettaError):

{letta_nightly-0.6.48.dev20250407104216 → letta_nightly-0.6.49.dev20250408030511}/letta/functions/function_sets/base.py

@@ -164,3 +164,68 @@ def core_memory_replace(agent_state: "AgentState", label: str, old_content: str,
     new_value = current_value.replace(str(old_content), str(new_content))
     agent_state.memory.update_block_value(label=label, value=new_value)
     return None
+
+
+def rethink_memory(agent_state: "AgentState", new_memory: str, target_block_label: 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.
+        target_block_label (str): The name of the block to write to.
+
+    Returns:
+        None: None is always returned as this function does not produce a response.
+    """
+
+    if agent_state.memory.get_block(target_block_label) is None:
+        agent_state.memory.create_block(label=target_block_label, value=new_memory)
+
+    agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
+    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
+
+
+def view_core_memory_with_line_numbers(agent_state: "AgentState", target_block_label: str) -> None:  # type: ignore
+    """
+    View the contents of core memory in editor mode with line numbers. Called before `core_memory_insert` to see line numbers of memory block.
+
+    Args:
+        target_block_label (str): The name of the block to view.
+
+    Returns:
+        None: None is always returned as this function does not produce a response.
+    """
+    return None
+
+
+def core_memory_insert(agent_state: "AgentState", target_block_label: str, new_memory: str, line_number: Optional[int] = None, replace: bool = False) -> None:  # type: ignore
+    """
+    Insert new memory content into a core memory block at a specific line number. Call `view_core_memory_with_line_numbers` to see line numbers of the memory block before using this tool.
+
+    Args:
+        target_block_label (str): The name of the block to write to.
+        new_memory (str): The new memory content to insert.
+        line_number (Optional[int]): Line number to insert content into, 0 indexed (None for end of file).
+        replace (bool): Whether to overwrite the content at the specified line number.
+
+    Returns:
+        None: None is always returned as this function does not produce a response.
+    """
+    current_value = str(agent_state.memory.get_block(target_block_label).value)
+    current_value_list = current_value.split("\n")
+    if line_number is None:
+        line_number = len(current_value_list)
+    current_value_list.insert(line_number, new_memory)
+    new_value = "\n".join(current_value_list)
+    agent_state.memory.update_block_value(label=target_block_label, value=new_value)
+    return None