letta-nightly 0.6.45.dev20250328104141__py3-none-any.whl → 0.6.46.dev20250330050944__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -58,7 +58,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.provider_manager import ProviderManager
 from letta.services.step_manager import StepManager
-from letta.services.tool_execution_sandbox import ToolExecutionSandbox
+from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.settings import summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
@@ -220,13 +220,14 @@ class Agent(BaseAgent):
         messages: List[Message],
         tool_returns: Optional[List[ToolReturn]] = None,
         include_function_failed_message: bool = False,
+        group_id: Optional[str] = None,
     ) -> List[Message]:
         """
         Handle error from function call response
         """
         # Update tool rules
         self.last_function_response = function_response
-        self.tool_rules_solver.update_tool_usage(function_name)
+        self.tool_rules_solver.register_tool_call(function_name)
 
         # Extend conversation with function response
         function_response = package_function_response(False, error_msg)
@@ -240,7 +241,9 @@ class Agent(BaseAgent):
                 "content": function_response,
                 "tool_call_id": tool_call_id,
             },
+            name=self.agent_state.name,
             tool_returns=tool_returns,
+            group_id=group_id,
         )
         messages.append(new_message)
         self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message)
@@ -302,10 +305,8 @@ class Agent(BaseAgent):
                 log_telemetry(self.logger, "_get_ai_reply create start")
                 # New LLM client flow
                 llm_client = LLMClient.create(
-                    agent_id=self.agent_state.id,
                     llm_config=self.agent_state.llm_config,
                     put_inner_thoughts_first=put_inner_thoughts_first,
-                    actor_id=self.agent_state.created_by_id,
                 )
 
                 if llm_client and not stream:
@@ -331,6 +332,7 @@ class Agent(BaseAgent):
                         stream=stream,
                         stream_interface=self.interface,
                         put_inner_thoughts_first=put_inner_thoughts_first,
+                        name=self.agent_state.name,
                     )
                 log_telemetry(self.logger, "_get_ai_reply create finish")
 
@@ -374,6 +376,7 @@ class Agent(BaseAgent):
         # and now we want to use it in the creation of the Message object
         # TODO figure out a cleaner way to do this
         response_message_id: Optional[str] = None,
+        group_id: Optional[str] = None,
     ) -> Tuple[List[Message], bool, bool]:
         """Handles parsing and function execution"""
         log_telemetry(self.logger, "_handle_ai_response start")
@@ -419,6 +422,8 @@ class Agent(BaseAgent):
                     user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict=response_message.model_dump(),
+                    name=self.agent_state.name,
+                    group_id=group_id,
                 )
             )  # extend conversation with assistant's reply
             self.logger.debug(f"Function call message: {messages[-1]}")
@@ -451,7 +456,7 @@ class Agent(BaseAgent):
                 error_msg = f"No function named {function_name}"
                 function_response = "None"  # more like "never ran?"
                 messages = self._handle_function_error_response(
-                    error_msg, tool_call_id, function_name, function_args, function_response, messages
+                    error_msg, tool_call_id, function_name, function_args, function_response, messages, group_id=group_id
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -466,7 +471,7 @@ class Agent(BaseAgent):
                 error_msg = f"Error parsing JSON for function '{function_name}' arguments: {function_call.arguments}"
                 function_response = "None"  # more like "never ran?"
                 messages = self._handle_function_error_response(
-                    error_msg, tool_call_id, function_name, function_args, function_response, messages
+                    error_msg, tool_call_id, function_name, function_args, function_response, messages, group_id=group_id
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -537,6 +542,7 @@ class Agent(BaseAgent):
                         function_response,
                         messages,
                         [tool_return],
+                        group_id=group_id,
                     )
                     return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -573,6 +579,7 @@ class Agent(BaseAgent):
                     messages,
                     [ToolReturn(status="error", stderr=[error_msg_user])],
                     include_function_failed_message=True,
+                    group_id=group_id,
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -597,6 +604,7 @@ class Agent(BaseAgent):
                     messages,
                     [tool_return],
                     include_function_failed_message=True,
+                    group_id=group_id,
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -622,7 +630,9 @@ class Agent(BaseAgent):
                         "content": function_response,
                         "tool_call_id": tool_call_id,
                     },
+                    name=self.agent_state.name,
                     tool_returns=[tool_return] if sandbox_run_result else None,
+                    group_id=group_id,
                 )
             )  # extend conversation with function response
             self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1])
@@ -638,6 +648,8 @@ class Agent(BaseAgent):
                     user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict=response_message.model_dump(),
+                    name=self.agent_state.name,
+                    group_id=group_id,
                 )
             )  # extend conversation with assistant's reply
             self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
@@ -649,7 +661,7 @@ class Agent(BaseAgent):
         self.agent_state = self.agent_manager.rebuild_system_prompt(agent_id=self.agent_state.id, actor=self.user)
 
         # Update ToolRulesSolver state with last called function
-        self.tool_rules_solver.update_tool_usage(function_name)
+        self.tool_rules_solver.register_tool_call(function_name)
         # Update heartbeat request according to provided tool rules
         if self.tool_rules_solver.has_children_tools(function_name):
             heartbeat_request = True
@@ -801,7 +813,11 @@ class Agent(BaseAgent):
             in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
             input_message_sequence = in_context_messages + messages
 
-            if len(input_message_sequence) > 1 and input_message_sequence[-1].role != "user":
+            if (
+                len(input_message_sequence) > 1
+                and input_message_sequence[-1].role != "user"
+                and input_message_sequence[-1].group_id is None
+            ):
                 self.logger.warning(f"{CLI_WARNING_PREFIX}Attempting to run ChatCompletion without user as the last message in the queue")
 
             # Step 2: send the conversation and available functions to the LLM
@@ -834,6 +850,7 @@ class Agent(BaseAgent):
                 # TODO this is kind of hacky, find a better way to handle this
                 # the only time we set up message creation ahead of time is when streaming is on
                 response_message_id=response.id if stream else None,
+                group_id=input_message_sequence[-1].group_id,
             )
 
             # Step 6: extend the message history

letta/agents/base_agent.py

@@ -1,10 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, List
+from typing import Any, AsyncGenerator, Optional
 
 import openai
 
 from letta.schemas.letta_message import UserMessage
-from letta.schemas.message import Message
+from letta.schemas.letta_response import LettaResponse
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.message_manager import MessageManager
@@ -19,7 +19,8 @@ class BaseAgent(ABC):
     def __init__(
         self,
         agent_id: str,
-        openai_client: openai.AsyncClient,
+        # TODO: Make required once client refactor hits
+        openai_client: Optional[openai.AsyncClient],
         message_manager: MessageManager,
         agent_manager: AgentManager,
         actor: User,
@@ -31,14 +32,14 @@ class BaseAgent(ABC):
         self.actor = actor
 
     @abstractmethod
-    async def step(self, input_message: UserMessage) -> List[Message]:
+    async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
         """
         Main execution loop for the agent.
         """
         raise NotImplementedError
 
     @abstractmethod
-    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> AsyncGenerator[str, None]:
         """
         Main async execution loop for the agent. Implementations must yield messages as SSE events.
         """

letta/agents/letta_agent.py

@@ -0,0 +1,323 @@
+import asyncio
+import json
+import uuid
+from typing import Any, AsyncGenerator, Dict, List, Tuple
+
+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.helpers import ToolRulesSolver
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.tool_execution_helper import enable_strict_mode
+from letta.llm_api.llm_client import LLMClient
+from letta.log import get_logger
+from letta.orm.enums import ToolType
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_message import AssistantMessage
+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.user import User
+from letta.server.rest_api.utils import create_tool_call_messages_from_openai_response, create_user_message
+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
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
+from letta.tracing import log_event, trace_method
+from letta.utils import united_diff
+
+logger = get_logger(__name__)
+
+
+class LettaAgent(BaseAgent):
+
+    def __init__(
+        self,
+        agent_id: str,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        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)
+
+        # TODO: Make this more general, factorable
+        # Summarizer settings
+        self.block_manager = block_manager
+        self.passage_manager = passage_manager
+        self.use_assistant_message = use_assistant_message
+
+    @trace_method
+    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
+        )
+        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
+        for step in range(max_steps):
+            response = await self._get_ai_reply(
+                in_context_messages=system_message + persisted_letta_messages,
+                agent_state=agent_state,
+                tool_rules_solver=tool_rules_solver,
+            )
+            persisted_messages, should_continue = await self._handle_ai_response(response, agent_state, tool_rules_solver)
+            persisted_letta_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)
+
+        return LettaResponse(
+            messages=response_messages,
+            # TODO: Actually populate this
+            usage=LettaUsageStatistics(),
+        )
+
+    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> 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")
+
+    @trace_method
+    async def _get_ai_reply(
+        self,
+        in_context_messages: List[Message],
+        agent_state: AgentState,
+        tool_rules_solver: ToolRulesSolver,
+    ) -> 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)
+            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]
+
+        llm_client = LLMClient.create(
+            llm_config=agent_state.llm_config,
+            put_inner_thoughts_first=True,
+        )
+
+        response = await llm_client.send_llm_request_async(
+            messages=in_context_messages,
+            tools=allowed_tools,
+            tool_call=None,
+            stream=False,
+        )
+
+        return response
+
+    @trace_method
+    async def _handle_ai_response(
+        self,
+        chat_completion_response: ChatCompletion,
+        agent_state: AgentState,
+        tool_rules_solver: ToolRulesSolver,
+    ) -> 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
+
+        try:
+            tool_args = json.loads(tool_call_args_str)
+        except json.JSONDecodeError:
+            tool_args = {}
+
+        # Get request heartbeats and coerce to bool
+        request_heartbeat = tool_args.pop("request_heartbeat", False)
+
+        # So this is necessary, because sometimes non-structured outputs makes mistakes
+        if not isinstance(request_heartbeat, bool):
+            if isinstance(request_heartbeat, str):
+                request_heartbeat = request_heartbeat.lower() == "true"
+            else:
+                request_heartbeat = bool(request_heartbeat)
+
+        tool_call_id = tool_call.id or f"call_{uuid.uuid4().hex[:8]}"
+
+        tool_result, success_flag = await self._execute_tool(
+            tool_name=tool_call_name,
+            tool_args=tool_args,
+            agent_state=agent_state,
+        )
+
+        # 4. Register tool call with tool rule solver
+        # Resolve whether or not to continue stepping
+        continue_stepping = request_heartbeat
+        tool_rules_solver.register_tool_call(tool_name=tool_call_name)
+        if tool_rules_solver.is_terminal_tool(tool_name=tool_call_name):
+            continue_stepping = False
+        elif tool_rules_solver.has_children_tools(tool_name=tool_call_name):
+            continue_stepping = True
+        elif tool_rules_solver.is_continue_tool(tool_name=tool_call_name):
+            continue_stepping = True
+
+        # 5. Persist to DB
+        tool_call_messages = create_tool_call_messages_from_openai_response(
+            agent_id=agent_state.id,
+            model=agent_state.llm_config.model,
+            function_name=tool_call_name,
+            function_arguments=tool_args,
+            tool_call_id=tool_call_id,
+            function_call_success=success_flag,
+            function_response=tool_result,
+            actor=self.actor,
+            add_heartbeat_request_system_message=continue_stepping,
+        )
+        persisted_messages = self.message_manager.create_many_messages(tool_call_messages, actor=self.actor)
+
+        return persisted_messages, continue_stepping
+
+    def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
+        self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
+
+        # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+        curr_system_message = in_context_messages[0]
+        curr_memory_str = agent_state.memory.compile()
+        curr_system_message_text = curr_system_message.content[0].text
+        if curr_memory_str in curr_system_message_text:
+            # NOTE: could this cause issues if a block is removed? (substring match would still work)
+            logger.debug(
+                f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+            )
+            return in_context_messages
+
+        memory_edit_timestamp = get_utc_time()
+
+        num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
+        num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+
+        new_system_message_str = compile_system_message(
+            system_prompt=agent_state.system,
+            in_context_memory=agent_state.memory,
+            in_context_memory_last_edit=memory_edit_timestamp,
+            previous_message_count=num_messages,
+            archival_memory_size=num_archival_memories,
+        )
+
+        diff = united_diff(curr_system_message_text, new_system_message_str)
+        if len(diff) > 0:
+            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+
+            new_system_message = self.message_manager.update_message_by_id(
+                curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
+            )
+
+            # Skip pulling down the agent's memory again to save on a db call
+            return [new_system_message] + in_context_messages[1:]
+
+        else:
+            return in_context_messages
+
+    @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
+
+        # TODO: This temp. Move this logic and code to executors
+        try:
+            if target_tool.name == "send_message_to_agents_matching_tags" and target_tool.tool_type == ToolType.LETTA_MULTI_AGENT_CORE:
+                log_event(name="start_send_message_to_agents_matching_tags", attributes=tool_args)
+                results = await self._send_message_to_agents_matching_tags(**tool_args)
+                log_event(name="finish_send_message_to_agents_matching_tags", attributes=tool_args)
+                return json.dumps(results), True
+            else:
+                tool_execution_manager = ToolExecutionManager(agent_state=agent_state, actor=self.actor)
+                # TODO: Integrate sandbox result
+                log_event(name=f"start_{tool_name}_execution", attributes=tool_args)
+                function_response, _ = await tool_execution_manager.execute_tool_async(
+                    function_name=tool_name, function_args=tool_args, tool=target_tool
+                )
+                log_event(name=f"finish_{tool_name}_execution", attributes=tool_args)
+                return function_response, True
+        except Exception as e:
+            return f"Failed to call tool. Error: {e}", False
+
+    @trace_method
+    async def _send_message_to_agents_matching_tags(
+        self, message: str, match_all: List[str], match_some: List[str]
+    ) -> List[Dict[str, Any]]:
+        # Find matching agents
+        matching_agents = self.agent_manager.list_agents_matching_tags(actor=self.actor, match_all=match_all, match_some=match_some)
+        if not matching_agents:
+            return []
+
+        async def process_agent(agent_state: AgentState, message: str) -> Dict[str, Any]:
+            try:
+                letta_agent = LettaAgent(
+                    agent_id=agent_state.id,
+                    message_manager=self.message_manager,
+                    agent_manager=self.agent_manager,
+                    block_manager=self.block_manager,
+                    passage_manager=self.passage_manager,
+                    actor=self.actor,
+                    use_assistant_message=True,
+                )
+
+                augmented_message = (
+                    "[Incoming message from external Letta agent - to reply to this message, "
+                    "make sure to use the 'send_message' at the end, and the system will notify "
+                    "the sender of your response] "
+                    f"{message}"
+                )
+
+                letta_response = await letta_agent.step(UserMessage(content=augmented_message))
+                messages = letta_response.messages
+
+                send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]
+
+                return {
+                    "agent_id": agent_state.id,
+                    "agent_name": agent_state.name,
+                    "response": send_message_content if send_message_content else ["<no response>"],
+                }
+
+            except Exception as e:
+                return {
+                    "agent_id": agent_state.id,
+                    "agent_name": agent_state.name,
+                    "error": str(e),
+                    "type": type(e).__name__,
+                }
+
+        tasks = [asyncio.create_task(process_agent(agent_state=agent_state, message=message)) for agent_state in matching_agents]
+        results = await asyncio.gather(*tasks)
+        return results

letta/agents/voice_agent.py

@@ -19,6 +19,7 @@ from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
+from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.openai.chat_completion_request import (
     AssistantMessage,
@@ -92,10 +93,10 @@ class VoiceAgent(BaseAgent):
             agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
         )
 
-    async def step(self, input_message: UserMessage) -> List[Message]:
+    async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
         raise NotImplementedError("LowLatencyAgent does not have a synchronous step implemented currently.")
 
-    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
@@ -107,7 +108,7 @@ class VoiceAgent(BaseAgent):
         in_memory_message_history = [input_message]
 
         # TODO: Define max steps here
-        while True:
+        for _ in range(max_steps):
             # Rebuild memory each loop
             in_context_messages = self._rebuild_memory(in_context_messages, agent_state)
             openai_messages = convert_letta_messages_to_openai(in_context_messages)

letta/client/client.py

@@ -546,6 +546,7 @@ class RESTClient(AbstractClient):
         tool_ids: Optional[List[str]] = None,
         tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
+        include_multi_agent_tools: Optional[bool] = False,
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
@@ -613,6 +614,7 @@ class RESTClient(AbstractClient):
             "tags": tags,
             "include_base_tools": include_base_tools,
             "message_buffer_autoclear": message_buffer_autoclear,
+            "include_multi_agent_tools": include_multi_agent_tools,
         }
 
         # Only add name if it's not None

letta/dynamic_multi_agent.py

@@ -16,7 +16,7 @@ class DynamicMultiAgent(Agent):
         self,
         interface: AgentInterface,
         agent_state: AgentState,
-        user: User = None,
+        user: User,
         # custom
         group_id: str = "",
         agent_ids: List[str] = [],
@@ -128,7 +128,7 @@ class DynamicMultiAgent(Agent):
                     )
                     for message in assistant_messages
                 ]
-                message_index[agent_id] = len(chat_history) + len(new_messages)
+                message_index[speaker_id] = len(chat_history) + len(new_messages)
 
                 # sum usage
                 total_usage.prompt_tokens += usage_stats.prompt_tokens
@@ -251,10 +251,10 @@ class DynamicMultiAgent(Agent):
         chat_history: List[Message],
         agent_id_options: List[str],
     ) -> Message:
-        chat_history = [f"{message.name or 'user'}: {message.content[0].text}" for message in chat_history]
+        text_chat_history = [f"{message.name or 'user'}: {message.content[0].text}" for message in chat_history]
         for message in new_messages:
-            chat_history.append(f"{message.name or 'user'}: {message.content}")
-        context_messages = "\n".join(chat_history)
+            text_chat_history.append(f"{message.name or 'user'}: {message.content}")
+        context_messages = "\n".join(text_chat_history)
 
         message_text = (
             "Choose the most suitable agent to reply to the latest message in the "

letta/errors.py

@@ -62,6 +62,26 @@ class LLMError(LettaError):
     pass
 
 
+class LLMConnectionError(LLMError):
+    """Error when unable to connect to LLM service"""
+
+
+class LLMRateLimitError(LLMError):
+    """Error when rate limited by LLM service"""
+
+
+class LLMPermissionDeniedError(LLMError):
+    """Error when permission is denied by LLM service"""
+
+
+class LLMNotFoundError(LLMError):
+    """Error when requested resource is not found"""
+
+
+class LLMUnprocessableEntityError(LLMError):
+    """Error when request is well-formed but semantically invalid"""
+
+
 class BedrockPermissionError(LettaError):
     """Exception raised for errors in the Bedrock permission process."""
 

letta/helpers/tool_execution_helper.py

@@ -10,7 +10,7 @@ from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxRunResult
 from letta.schemas.tool import Tool
 from letta.schemas.user import User
-from letta.services.tool_execution_sandbox import ToolExecutionSandbox
+from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.utils import get_friendly_error_msg
 
 

letta/helpers/tool_rule_solver.py

@@ -62,7 +62,7 @@ class ToolRulesSolver(BaseModel):
                 assert isinstance(rule, MaxCountPerStepToolRule)
                 self.child_based_tool_rules.append(rule)
 
-    def update_tool_usage(self, tool_name: str):
+    def register_tool_call(self, tool_name: str):
         """Update the internal state to track tool call history."""
         self.tool_call_history.append(tool_name)
 

letta/llm_api/anthropic.py

@@ -859,6 +859,7 @@ def anthropic_chat_completions_process_stream(
     create_message_id: bool = True,
     create_message_datetime: bool = True,
     betas: List[str] = ["tools-2024-04-04"],
+    name: Optional[str] = None,
 ) -> ChatCompletionResponse:
     """Process a streaming completion response from Anthropic, similar to OpenAI's streaming.
 
@@ -951,6 +952,7 @@ def anthropic_chat_completions_process_stream(
                         # if extended_thinking is on, then reasoning_content will be flowing as chunks
                         # TODO handle emitting redacted reasoning content (e.g. as concat?)
                         expect_reasoning_content=extended_thinking,
+                        name=name,
                     )
                 elif isinstance(stream_interface, AgentRefreshStreamingInterface):
                     stream_interface.process_refresh(chat_completion_response)