letta-nightly 0.6.45.dev20250329104117__py3-none-any.whl → 0.6.46.dev20250330104049__py3-none-any.whl

letta/llm_api/llm_client_base.py

@@ -18,17 +18,13 @@ class LLMClientBase:
 
     def __init__(
         self,
-        agent_id: str,
         llm_config: LLMConfig,
         put_inner_thoughts_first: Optional[bool] = True,
         use_structured_output: Optional[bool] = True,
         use_tool_naming: bool = True,
-        actor_id: Optional[str] = None,
     ):
-        self.agent_id = agent_id
         self.llm_config = llm_config
         self.put_inner_thoughts_first = put_inner_thoughts_first
-        self.actor_id = actor_id
         self.use_tool_naming = use_tool_naming
 
     def send_llm_request(
@@ -46,13 +42,18 @@ class LLMClientBase:
         Otherwise returns a ChatCompletionResponse.
         """
         request_data = self.build_request_data(messages, tools, tool_call)
-        log_event(name="llm_request_sent", attributes=request_data)
-        if stream:
-            return self.stream(request_data)
-        else:
-            response_data = self.request(request_data)
+
+        try:
+            log_event(name="llm_request_sent", attributes=request_data)
+            if stream:
+                return self.stream(request_data)
+            else:
+                response_data = self.request(request_data)
             log_event(name="llm_response_received", attributes=response_data)
-            return self.convert_response_to_chat_completion(response_data, messages)
+        except Exception as e:
+            raise self.handle_llm_error(e)
+
+        return self.convert_response_to_chat_completion(response_data, messages)
 
     async def send_llm_request_async(
         self,
@@ -68,14 +69,20 @@ class LLMClientBase:
         If stream=True, returns an AsyncStream[ChatCompletionChunk] that can be async iterated over.
         Otherwise returns a ChatCompletionResponse.
         """
-        request_data = self.build_request_data(messages, tools, tool_call)
-        log_event(name="llm_request_sent", attributes=request_data)
-        if stream:
-            return await self.stream_async(request_data)
-        else:
-            response_data = await self.request_async(request_data)
+        request_data = self.build_request_data(messages, tools, tool_call, force_tool_call)
+        response_data = {}
+
+        try:
+            log_event(name="llm_request_sent", attributes=request_data)
+            if stream:
+                return await self.stream_async(request_data)
+            else:
+                response_data = await self.request_async(request_data)
             log_event(name="llm_response_received", attributes=response_data)
-            return self.convert_response_to_chat_completion(response_data, messages)
+        except Exception as e:
+            raise self.handle_llm_error(e)
+
+        return self.convert_response_to_chat_completion(response_data, messages)
 
     @abstractmethod
     def build_request_data(
@@ -129,3 +136,17 @@ class LLMClientBase:
         Performs underlying streaming request to llm and returns raw response.
         """
         raise NotImplementedError(f"Streaming is not supported for {self.llm_config.model_endpoint_type}")
+
+    @abstractmethod
+    def handle_llm_error(self, e: Exception) -> Exception:
+        """
+        Maps provider-specific errors to common LLMError types.
+        Each LLM provider should implement this to translate their specific errors.
+
+        Args:
+            e: The original provider-specific exception
+
+        Returns:
+            An LLMError subclass that represents the error in a provider-agnostic way
+        """
+        return LLMError(f"Unhandled LLM error: {str(e)}")

letta/llm_api/openai.py

@@ -185,6 +185,7 @@ def openai_chat_completions_process_stream(
     # however, we don't necessarily want to put these
     # expect_reasoning_content: bool = False,
     expect_reasoning_content: bool = True,
+    name: Optional[str] = None,
 ) -> ChatCompletionResponse:
     """Process a streaming completion response, and return a ChatCompletionRequest at the end.
 
@@ -272,6 +273,7 @@ def openai_chat_completions_process_stream(
                         message_id=chat_completion_response.id if create_message_id else chat_completion_chunk.id,
                         message_date=chat_completion_response.created if create_message_datetime else chat_completion_chunk.created,
                         expect_reasoning_content=expect_reasoning_content,
+                        name=name,
                     )
                 elif isinstance(stream_interface, AgentRefreshStreamingInterface):
                     stream_interface.process_refresh(chat_completion_response)

letta/orm/group.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import List, Optional
 
-from sqlalchemy import ForeignKey, String
+from sqlalchemy import JSON, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -23,11 +23,8 @@ class Group(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="groups")
+    agent_ids: Mapped[List[str]] = mapped_column(JSON, nullable=False, doc="Ordered list of agent IDs in this group")
     agents: Mapped[List["Agent"]] = relationship(
         "Agent", secondary="groups_agents", lazy="selectin", passive_deletes=True, back_populates="groups"
     )
     manager_agent: Mapped["Agent"] = relationship("Agent", lazy="joined", back_populates="multi_agent_group")
-
-    @property
-    def agent_ids(self) -> List[str]:
-        return [agent.id for agent in self.agents]

letta/round_robin_multi_agent.py

@@ -14,7 +14,7 @@ class RoundRobinMultiAgent(Agent):
         self,
         interface: AgentInterface,
         agent_state: AgentState,
-        user: User = None,
+        user: User,
         # custom
         group_id: str = "",
         agent_ids: List[str] = [],
@@ -45,7 +45,7 @@ class RoundRobinMultiAgent(Agent):
         for agent_id in self.agent_ids:
             agents[agent_id] = self.load_participant_agent(agent_id=agent_id)
 
-        message_index = {}
+        message_index = {agent_id: 0 for agent_id in self.agent_ids}
         chat_history: List[Message] = []
         new_messages = messages
         speaker_id = None
@@ -91,7 +91,7 @@ class RoundRobinMultiAgent(Agent):
                     MessageCreate(
                         role="system",
                         content=message.content,
-                        name=participant_agent.agent_state.name,
+                        name=message.name,
                     )
                     for message in assistant_messages
                 ]
@@ -138,10 +138,21 @@ class RoundRobinMultiAgent(Agent):
         agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=self.user)
         persona_block = agent_state.memory.get_block(label="persona")
         group_chat_participant_persona = (
-            "\n\n====Group Chat Contex===="
-            f"\nYou are speaking in a group chat with {len(self.agent_ids) - 1} other "
-            "agents and one user. Respond to new messages in the group chat when prompted. "
-            f"Description of the group: {self.description}"
+            f"%%% GROUP CHAT CONTEXT %%% "
+            f"You are speaking in a group chat with {len(self.agent_ids)} other participants. "
+            f"Group Description: {self.description} "
+            "INTERACTION GUIDELINES:\n"
+            "1. Be aware that others can see your messages - communicate as if in a real group conversation\n"
+            "2. Acknowledge and build upon others' contributions when relevant\n"
+            "3. Stay on topic while adding your unique perspective based on your role and personality\n"
+            "4. Be concise but engaging - give others space to contribute\n"
+            "5. Maintain your character's personality while being collaborative\n"
+            "6. Feel free to ask questions to other participants to encourage discussion\n"
+            "7. If someone addresses you directly, acknowledge their message\n"
+            "8. Share relevant experiences or knowledge that adds value to the conversation\n\n"
+            "Remember: This is a natural group conversation. Interact as you would in a real group setting, "
+            "staying true to your character while fostering meaningful dialogue. "
+            "%%% END GROUP CHAT CONTEXT %%%"
         )
         agent_state.memory.update_block_value(label="persona", value=persona_block.value + group_chat_participant_persona)
         return Agent(

letta/schemas/group.py

@@ -62,4 +62,10 @@ ManagerConfigUnion = Annotated[
 class GroupCreate(BaseModel):
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
+    manager_config: ManagerConfigUnion = Field(RoundRobinManager(), description="")
+
+
+class GroupUpdate(BaseModel):
+    agent_ids: Optional[List[str]] = Field(None, description="")
+    description: Optional[str] = Field(None, description="")
     manager_config: Optional[ManagerConfigUnion] = Field(None, description="")

letta/schemas/message.py

@@ -226,6 +226,7 @@ class Message(BaseMessage):
                             id=self.id,
                             date=self.created_at,
                             reasoning=self.content[0].text,
+                            name=self.name,
                         )
                     )
                 # Otherwise, we may have a list of multiple types
@@ -239,6 +240,7 @@ class Message(BaseMessage):
                                     id=self.id,
                                     date=self.created_at,
                                     reasoning=content_part.text,
+                                    name=self.name,
                                 )
                             )
                         elif isinstance(content_part, ReasoningContent):
@@ -250,6 +252,7 @@ class Message(BaseMessage):
                                     reasoning=content_part.reasoning,
                                     source="reasoner_model",  # TODO do we want to tag like this?
                                     signature=content_part.signature,
+                                    name=self.name,
                                 )
                             )
                         elif isinstance(content_part, RedactedReasoningContent):
@@ -260,6 +263,7 @@ class Message(BaseMessage):
                                     date=self.created_at,
                                     state="redacted",
                                     hidden_reasoning=content_part.data,
+                                    name=self.name,
                                 )
                             )
                         else:
@@ -282,6 +286,7 @@ class Message(BaseMessage):
                                 id=self.id,
                                 date=self.created_at,
                                 content=message_string,
+                                name=self.name,
                             )
                         )
                     else:
@@ -294,6 +299,7 @@ class Message(BaseMessage):
                                     arguments=tool_call.function.arguments,
                                     tool_call_id=tool_call.id,
                                 ),
+                                name=self.name,
                             )
                         )
         elif self.role == MessageRole.tool:
@@ -334,6 +340,7 @@ class Message(BaseMessage):
                     tool_call_id=self.tool_call_id,
                     stdout=self.tool_returns[0].stdout if self.tool_returns else None,
                     stderr=self.tool_returns[0].stderr if self.tool_returns else None,
+                    name=self.name,
                 )
             )
         elif self.role == MessageRole.user:
@@ -349,6 +356,7 @@ class Message(BaseMessage):
                     id=self.id,
                     date=self.created_at,
                     content=message_str or text_content,
+                    name=self.name,
                 )
             )
         elif self.role == MessageRole.system:
@@ -363,6 +371,7 @@ class Message(BaseMessage):
                     id=self.id,
                     date=self.created_at,
                     content=text_content,
+                    name=self.name,
                 )
             )
         else:
@@ -379,6 +388,8 @@ class Message(BaseMessage):
         allow_functions_style: bool = False,  # allow deprecated functions style?
         created_at: Optional[datetime] = None,
         id: Optional[str] = None,
+        name: Optional[str] = None,
+        group_id: Optional[str] = None,
         tool_returns: Optional[List[ToolReturn]] = None,
     ):
         """Convert a ChatCompletion message object into a Message object (synced to DB)"""
@@ -426,12 +437,13 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
                     content=content,
-                    name=openai_message_dict["name"] if "name" in openai_message_dict else None,
+                    name=name,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     id=str(id),
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
             else:
                 return Message(
@@ -440,11 +452,12 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
                     content=content,
-                    name=openai_message_dict["name"] if "name" in openai_message_dict else None,
+                    name=name,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
 
         elif "function_call" in openai_message_dict and openai_message_dict["function_call"] is not None:
@@ -473,12 +486,13 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
                     content=content,
-                    name=openai_message_dict["name"] if "name" in openai_message_dict else None,
+                    name=name,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
                     created_at=created_at,
                     id=str(id),
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
             else:
                 return Message(
@@ -492,6 +506,7 @@ class Message(BaseMessage):
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
                     created_at=created_at,
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
 
         else:
@@ -520,12 +535,13 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
                     content=content,
-                    name=openai_message_dict["name"] if "name" in openai_message_dict else None,
+                    name=name,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     id=str(id),
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
             else:
                 return Message(
@@ -534,11 +550,12 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
                     content=content,
-                    name=openai_message_dict["name"] if "name" in openai_message_dict else None,
+                    name=name,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     tool_returns=tool_returns,
+                    group_id=group_id,
                 )
 
     def to_openai_dict_search_results(self, max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN) -> dict:
@@ -579,9 +596,6 @@ class Message(BaseMessage):
                 "content": text_content,
                 "role": self.role,
             }
-            # Optional field, do not include if null
-            if self.name is not None:
-                openai_message["name"] = self.name
 
         elif self.role == "user":
             assert all([v is not None for v in [text_content, self.role]]), vars(self)
@@ -589,9 +603,6 @@ class Message(BaseMessage):
                 "content": text_content,
                 "role": self.role,
             }
-            # Optional field, do not include if null
-            if self.name is not None:
-                openai_message["name"] = self.name
 
         elif self.role == "assistant":
             assert self.tool_calls is not None or text_content is not None
@@ -599,9 +610,7 @@ class Message(BaseMessage):
                 "content": None if put_inner_thoughts_in_kwargs else text_content,
                 "role": self.role,
             }
-            # Optional fields, do not include if null
-            if self.name is not None:
-                openai_message["name"] = self.name
+
             if self.tool_calls is not None:
                 if put_inner_thoughts_in_kwargs:
                     # put the inner thoughts inside the tool call before casting to a dict

letta/schemas/openai/chat_completion_request.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class SystemMessage(BaseModel):
@@ -140,3 +140,8 @@ class ChatCompletionRequest(BaseModel):
     # deprecated scheme
     functions: Optional[List[FunctionSchema]] = None
     function_call: Optional[FunctionCallChoice] = None
+
+    @field_validator("messages", mode="before")
+    @classmethod
+    def cast_all_messages(cls, v):
+        return [cast_message_to_subtype(m) if isinstance(m, dict) else m for m in v]

letta/schemas/providers.py

@@ -1120,7 +1120,7 @@ class GoogleAIProvider(Provider):
     base_url: str = "https://generativelanguage.googleapis.com"
 
     def list_llm_models(self):
-        from letta.llm_api.google_ai import google_ai_get_model_list
+        from letta.llm_api.google_ai_client import google_ai_get_model_list
 
         model_options = google_ai_get_model_list(base_url=self.base_url, api_key=self.api_key)
         # filter by 'generateContent' models
@@ -1149,7 +1149,7 @@ class GoogleAIProvider(Provider):
         return configs
 
     def list_embedding_models(self):
-        from letta.llm_api.google_ai import google_ai_get_model_list
+        from letta.llm_api.google_ai_client import google_ai_get_model_list
 
         # TODO: use base_url instead
         model_options = google_ai_get_model_list(base_url=self.base_url, api_key=self.api_key)
@@ -1173,7 +1173,7 @@ class GoogleAIProvider(Provider):
         return configs
 
     def get_model_context_window(self, model_name: str) -> Optional[int]:
-        from letta.llm_api.google_ai import google_ai_get_model_context_window
+        from letta.llm_api.google_ai_client import google_ai_get_model_context_window
 
         return google_ai_get_model_context_window(self.base_url, self.api_key, model_name)
 

letta/serialize_schemas/marshmallow_agent.py

@@ -27,11 +27,12 @@ class MarshmallowAgentSchema(BaseSchema):
     FIELD_VERSION = "version"
     FIELD_MESSAGES = "messages"
     FIELD_MESSAGE_IDS = "message_ids"
-    FIELD_IN_CONTEXT = "in_context"
+    FIELD_IN_CONTEXT_INDICES = "in_context_message_indices"
     FIELD_ID = "id"
 
     llm_config = LLMConfigField()
     embedding_config = EmbeddingConfigField()
+
     tool_rules = ToolRulesField()
 
     messages = fields.List(fields.Nested(SerializedMessageSchema))
@@ -58,20 +59,39 @@ class MarshmallowAgentSchema(BaseSchema):
         """
         - Removes `message_ids`
         - Adds versioning
-        - Marks messages as in-context
+        - Marks messages as in-context, preserving the order of the original `message_ids`
         - Removes individual message `id` fields
         """
         data = super().sanitize_ids(data, **kwargs)
         data[self.FIELD_VERSION] = letta.__version__
 
-        message_ids = set(data.pop(self.FIELD_MESSAGE_IDS, []))  # Store and remove message_ids
+        original_message_ids = data.pop(self.FIELD_MESSAGE_IDS, [])
+        messages = data.get(self.FIELD_MESSAGES, [])
+
+        # Build a mapping from message id to its first occurrence index and remove the id in one pass
+        id_to_index = {}
+        for idx, message in enumerate(messages):
+            msg_id = message.pop(self.FIELD_ID, None)
+            if msg_id is not None and msg_id not in id_to_index:
+                id_to_index[msg_id] = idx
+
+        # Build in-context indices in the same order as the original message_ids
+        in_context_indices = [id_to_index[msg_id] for msg_id in original_message_ids if msg_id in id_to_index]
 
-        for message in data.get(self.FIELD_MESSAGES, []):
-            message[self.FIELD_IN_CONTEXT] = message[self.FIELD_ID] in message_ids  # Mark messages as in-context
-            message.pop(self.FIELD_ID, None)  # Remove the id field
+        data[self.FIELD_IN_CONTEXT_INDICES] = in_context_indices
+        data[self.FIELD_MESSAGES] = messages
 
         return data
 
+    @post_dump
+    def hide_tool_exec_environment_variables(self, data: Dict, **kwargs):
+        """Hide the value of tool_exec_environment_variables"""
+
+        for env_var in data.get("tool_exec_environment_variables", []):
+            # need to be re-set at load time
+            env_var["value"] = ""
+        return data
+
     @pre_load
     def check_version(self, data, **kwargs):
         """Check version and remove it from the schema"""
@@ -87,13 +107,17 @@ class MarshmallowAgentSchema(BaseSchema):
         Restores `message_ids` by collecting message IDs where `in_context` is True,
         generates new IDs for all messages, and removes `in_context` from all messages.
         """
-        message_ids = []
-        for msg in data.get(self.FIELD_MESSAGES, []):
+        messages = data.get(self.FIELD_MESSAGES, [])
+        for msg in messages:
             msg[self.FIELD_ID] = SerializedMessageSchema.generate_id()  # Generate new ID
-            if msg.pop(self.FIELD_IN_CONTEXT, False):  # If it was in-context, track its new ID
-                message_ids.append(msg[self.FIELD_ID])
+
+        message_ids = []
+        in_context_message_indices = data.pop(self.FIELD_IN_CONTEXT_INDICES)
+        for idx in in_context_message_indices:
+            message_ids.append(messages[idx][self.FIELD_ID])
 
         data[self.FIELD_MESSAGE_IDS] = message_ids
+
         return data
 
     class Meta(BaseSchema.Meta):

letta/serialize_schemas/pydantic_agent_schema.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel, Field
 
@@ -22,7 +22,6 @@ class CoreMemoryBlockSchema(BaseModel):
 class MessageSchema(BaseModel):
     created_at: str
     group_id: Optional[str]
-    in_context: bool
     model: Optional[str]
     name: Optional[str]
     role: str
@@ -45,11 +44,31 @@ class ToolEnvVarSchema(BaseModel):
     value: str
 
 
-class ToolRuleSchema(BaseModel):
+# Tool rules
+
+
+class BaseToolRuleSchema(BaseModel):
     tool_name: str
     type: str
 
 
+class ChildToolRuleSchema(BaseToolRuleSchema):
+    children: List[str]
+
+
+class MaxCountPerStepToolRuleSchema(BaseToolRuleSchema):
+    max_count_limit: int
+
+
+class ConditionalToolRuleSchema(BaseToolRuleSchema):
+    default_child: Optional[str]
+    child_output_mapping: Dict[Any, str]
+    require_output_mapping: bool
+
+
+ToolRuleSchema = Union[BaseToolRuleSchema, ChildToolRuleSchema, MaxCountPerStepToolRuleSchema, ConditionalToolRuleSchema]
+
+
 class ParameterProperties(BaseModel):
     type: str
     description: Optional[str] = None
@@ -92,6 +111,7 @@ class AgentSchema(BaseModel):
     embedding_config: EmbeddingConfig
     llm_config: LLMConfig
     message_buffer_autoclear: bool
+    in_context_message_indices: List[int]
     messages: List[MessageSchema]
     metadata_: Optional[Dict] = None
     multi_agent_group: Optional[Any]

letta/server/rest_api/app.py

@@ -1,3 +1,5 @@
+import asyncio
+import concurrent.futures
 import json
 import logging
 import os
@@ -135,6 +137,13 @@ def create_application() -> "FastAPI":
         debug=debug_mode,  # if True, the stack trace will be printed in the response
     )
 
+    @app.on_event("startup")
+    async def configure_executor():
+        print(f"Configured event loop executor with {settings.event_loop_threadpool_max_workers} workers.")
+        loop = asyncio.get_running_loop()
+        executor = concurrent.futures.ThreadPoolExecutor(max_workers=settings.event_loop_threadpool_max_workers)
+        loop.set_default_executor(executor)
+
     @app.on_event("shutdown")
     def shutdown_mcp_clients():
         global server