letta-nightly 0.6.43.dev20250324104208__py3-none-any.whl → 0.6.44.dev20250325104221__py3-none-any.whl

letta/server/server.py

@@ -26,6 +26,7 @@ from letta.functions.mcp_client.stdio_client import StdioMCPClient
 from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
+from letta.helpers.message_helper import prepare_input_message_create
 
 # TODO use custom interface
 from letta.interface import AgentInterface  # abstract
@@ -48,7 +49,7 @@ from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, Memory, RecallMemorySummary
-from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.providers import (
@@ -85,7 +86,6 @@ from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.passage_manager import PassageManager
-from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.services.provider_manager import ProviderManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
@@ -210,9 +210,6 @@ class SyncServer(Server):
         self.identity_manager = IdentityManager()
         self.group_manager = GroupManager()
 
-        # Managers that interface with parallelism
-        self.per_agent_lock_manager = PerAgentLockManager()
-
         # Make default user and org
         if init_with_default_org_and_user:
             self.default_org = self.organization_manager.create_default_organization()
@@ -353,21 +350,19 @@ class SyncServer(Server):
 
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
-        agent_lock = self.per_agent_lock_manager.get_lock(agent_id)
-        with agent_lock:
-            agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-            if agent_state.multi_agent_group:
-                return self.load_multi_agent(agent_state.multi_agent_group, actor, interface, agent_state)
-
-            interface = interface or self.default_interface_factory()
-            if agent_state.agent_type == AgentType.memgpt_agent:
-                agent = Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
-            elif agent_state.agent_type == AgentType.offline_memory_agent:
-                agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
-            else:
-                raise ValueError(f"Invalid agent type {agent_state.agent_type}")
+        agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+        if agent_state.multi_agent_group:
+            return self.load_multi_agent(agent_state.multi_agent_group, actor, interface, agent_state)
+
+        interface = interface or self.default_interface_factory()
+        if agent_state.agent_type == AgentType.memgpt_agent:
+            agent = Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
+        elif agent_state.agent_type == AgentType.offline_memory_agent:
+            agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
+        else:
+            raise ValueError(f"Invalid agent type {agent_state.agent_type}")
 
-            return agent
+        return agent
 
     def load_multi_agent(
         self, group: Group, actor: User, interface: Union[AgentInterface, None] = None, agent_state: Optional[AgentState] = None
@@ -702,63 +697,22 @@ class SyncServer(Server):
         actor: User,
         agent_id: str,
         messages: Union[List[MessageCreate], List[Message]],
-        # whether or not to wrap user and system message as MemGPT-style stringified JSON
         wrap_user_message: bool = True,
         wrap_system_message: bool = True,
-        interface: Union[AgentInterface, ChatCompletionsStreamingInterface, None] = None,  # needed to getting responses
+        interface: Union[AgentInterface, ChatCompletionsStreamingInterface, None] = None,  # needed for responses
         metadata: Optional[dict] = None,  # Pass through metadata to interface
         put_inner_thoughts_first: bool = True,
     ) -> LettaUsageStatistics:
-        """Send a list of messages to the agent
+        """Send a list of messages to the agent.
 
-        If the messages are of type MessageCreate, we need to turn them into
-        Message objects first before sending them through step.
-
-        Otherwise, we can pass them in directly.
+        If messages are of type MessageCreate, convert them to Message objects before sending.
         """
-        message_objects: List[Message] = []
-
         if all(isinstance(m, MessageCreate) for m in messages):
-            for message in messages:
-                assert isinstance(message, MessageCreate)
-
-                # If wrapping is enabled, wrap with metadata before placing content inside the Message object
-                if isinstance(message.content, str):
-                    message_content = message.content
-                elif message.content and len(message.content) > 0 and isinstance(message.content[0], TextContent):
-                    message_content = message.content[0].text
-                else:
-                    assert message_content is not None, "Message content is empty"
-
-                if message.role == MessageRole.user and wrap_user_message:
-                    message_content = system.package_user_message(user_message=message_content)
-                elif message.role == MessageRole.system and wrap_system_message:
-                    message_content = system.package_system_message(system_message=message_content)
-                else:
-                    raise ValueError(f"Invalid message role: {message.role}")
-
-                # Create the Message object
-                message_objects.append(
-                    Message(
-                        agent_id=agent_id,
-                        role=message.role,
-                        content=[TextContent(text=message_content)] if message_content else [],
-                        name=message.name,
-                        # assigned later?
-                        model=None,
-                        # irrelevant
-                        tool_calls=None,
-                        tool_call_id=None,
-                    )
-                )
-
+            message_objects = [prepare_input_message_create(m, agent_id, wrap_user_message, wrap_system_message) for m in messages]
         elif all(isinstance(m, Message) for m in messages):
-            for message in messages:
-                assert isinstance(message, Message)
-                message_objects.append(message)
-
+            message_objects = messages
         else:
-            raise ValueError(f"All messages must be of type Message or MessageCreate, got {[type(message) for message in messages]}")
+            raise ValueError(f"All messages must be of type Message or MessageCreate, got {[type(m) for m in messages]}")
 
         # Store metadata in interface if provided
         if metadata and hasattr(interface, "metadata"):
@@ -792,7 +746,13 @@ class SyncServer(Server):
         if request.llm_config is None:
             if request.model is None:
                 raise ValueError("Must specify either model or llm_config in request")
-            request.llm_config = self.get_llm_config_from_handle(handle=request.model, context_window_limit=request.context_window_limit)
+            request.llm_config = self.get_llm_config_from_handle(
+                handle=request.model,
+                context_window_limit=request.context_window_limit,
+                max_tokens=request.max_tokens,
+                max_reasoning_tokens=request.max_reasoning_tokens,
+                enable_reasoner=request.enable_reasoner,
+            )
 
         if request.embedding_config is None:
             if request.embedding is None:
@@ -830,6 +790,8 @@ class SyncServer(Server):
         limit: Optional[int] = 100,
         order_by: Optional[str] = "created_at",
         reverse: Optional[bool] = False,
+        query_text: Optional[str] = None,
+        ascending: Optional[bool] = True,
     ) -> List[Passage]:
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
@@ -839,9 +801,10 @@ class SyncServer(Server):
             actor=actor,
             agent_id=agent_id,
             after=after,
+            query_text=query_text,
             before=before,
+            ascending=ascending,
             limit=limit,
-            ascending=not reverse,
         )
         return records
 
@@ -1099,7 +1062,14 @@ class SyncServer(Server):
         # Merge the two dictionaries, keeping the values from providers_from_db where conflicts occur
         return {**providers_from_env, **providers_from_db}.values()
 
-    def get_llm_config_from_handle(self, handle: str, context_window_limit: Optional[int] = None) -> LLMConfig:
+    def get_llm_config_from_handle(
+        self,
+        handle: str,
+        context_window_limit: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        max_reasoning_tokens: Optional[int] = None,
+        enable_reasoner: Optional[bool] = None,
+    ) -> LLMConfig:
         try:
             provider_name, model_name = handle.split("/", 1)
             provider = self.get_provider_from_name(provider_name)
@@ -1121,13 +1091,22 @@ class SyncServer(Server):
         else:
             llm_config = llm_configs[0]
 
-        if context_window_limit:
+        if context_window_limit is not None:
             if context_window_limit > llm_config.context_window:
                 raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
             llm_config.context_window = context_window_limit
         else:
             llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
 
+        if max_tokens is not None:
+            llm_config.max_tokens = max_tokens
+        if max_reasoning_tokens is not None:
+            if not max_tokens or max_reasoning_tokens > max_tokens:
+                raise ValueError(f"Max reasoning tokens ({max_reasoning_tokens}) must be less than max tokens ({max_tokens})")
+            llm_config.max_reasoning_tokens = max_reasoning_tokens
+        if enable_reasoner is not None:
+            llm_config.enable_reasoner = enable_reasoner
+
         return llm_config
 
     def get_embedding_config_from_handle(

letta/services/agent_manager.py

@@ -349,6 +349,7 @@ class AgentManager:
         identity_id: Optional[str] = None,
         identifier_keys: Optional[List[str]] = None,
         include_relationships: Optional[List[str]] = None,
+        ascending: bool = True,
     ) -> List[PydanticAgentState]:
         """
         Retrieves agents with optimized filtering and optional field selection.
@@ -368,6 +369,7 @@ class AgentManager:
             identity_id (Optional[str]): Filter by identifier ID.
             identifier_keys (Optional[List[str]]): Search agents by identifier keys.
             include_relationships (Optional[List[str]]): List of fields to load for performance optimization.
+            ascending
 
         Returns:
             List[PydanticAgentState]: The filtered list of matching agents.
@@ -380,7 +382,7 @@ class AgentManager:
             query = _apply_filters(query, name, query_text, project_id, template_id, base_template_id)
             query = _apply_identity_filters(query, identity_id, identifier_keys)
             query = _apply_tag_filter(query, tags, match_all_tags)
-            query = _apply_pagination(query, before, after, session)
+            query = _apply_pagination(query, before, after, session, ascending=ascending)
 
             query = query.limit(limit)
 
@@ -639,7 +641,7 @@ class AgentManager:
 
         diff = united_diff(curr_system_message_openai["content"], new_system_message_str)
         if len(diff) > 0:  # there was a diff
-            logger.info(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
 
             # Swap the system message out (only if there is a diff)
             message = PydanticMessage.dict_to_message(
@@ -742,6 +744,8 @@ class AgentManager:
         Update internal memory object and system prompt if there have been modifications.
 
         Args:
+            actor:
+            agent_id:
             new_memory (Memory): the new memory object to compare to the current memory object
 
         Returns:

letta/services/helpers/agent_manager_helper.py

@@ -1,7 +1,7 @@
 import datetime
 from typing import List, Literal, Optional
 
-from sqlalchemy import and_, func, literal, or_, select
+from sqlalchemy import and_, asc, desc, func, literal, or_, select
 
 from letta import system
 from letta.constants import IN_CONTEXT_MEMORY_KEYWORD, STRUCTURED_OUTPUT_MODELS
@@ -299,55 +299,41 @@ def check_supports_structured_output(model: str, tool_rules: List[ToolRule]) ->
         return True
 
 
-def _apply_pagination(query, before: Optional[str], after: Optional[str], session) -> any:
+def _cursor_filter(created_at_col, id_col, ref_created_at, ref_id, forward: bool):
     """
-    Apply cursor-based pagination filters using the agent's created_at timestamp with id as a tie-breaker.
+    Returns a SQLAlchemy filter expression for cursor-based pagination.
 
-    Instead of relying on the UUID ordering, this function uses the agent's creation time
-    (and id for tie-breaking) to paginate the results. It performs a minimal lookup to fetch
-    only the created_at and id for the agent corresponding to the provided cursor.
+    If `forward` is True, returns records after the reference.
+    If `forward` is False, returns records before the reference.
+    """
+    if forward:
+        return or_(
+            created_at_col > ref_created_at,
+            and_(created_at_col == ref_created_at, id_col > ref_id),
+        )
+    else:
+        return or_(
+            created_at_col < ref_created_at,
+            and_(created_at_col == ref_created_at, id_col < ref_id),
+        )
 
-    Args:
-        query: The SQLAlchemy query object to modify.
-        before (Optional[str]): Cursor (agent id) to return agents created before this agent.
-        after (Optional[str]): Cursor (agent id) to return agents created after this agent.
-        session: The active database session used to execute the minimal lookup.
 
-    Returns:
-        The modified query with pagination filters applied and ordered by created_at and id.
-    """
+def _apply_pagination(query, before: Optional[str], after: Optional[str], session, ascending: bool = True) -> any:
     if after:
-        # Retrieve only the created_at and id for the agent corresponding to the 'after' cursor.
         result = session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == after)).first()
         if result:
             after_created_at, after_id = result
-            # Filter: include agents created after the reference, or at the same time but with a greater id.
-            query = query.where(
-                or_(
-                    AgentModel.created_at > after_created_at,
-                    and_(
-                        AgentModel.created_at == after_created_at,
-                        AgentModel.id > after_id,
-                    ),
-                )
-            )
+            query = query.where(_cursor_filter(AgentModel.created_at, AgentModel.id, after_created_at, after_id, forward=ascending))
+
     if before:
-        # Retrieve only the created_at and id for the agent corresponding to the 'before' cursor.
         result = session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == before)).first()
         if result:
             before_created_at, before_id = result
-            # Filter: include agents created before the reference, or at the same time but with a smaller id.
-            query = query.where(
-                or_(
-                    AgentModel.created_at < before_created_at,
-                    and_(
-                        AgentModel.created_at == before_created_at,
-                        AgentModel.id < before_id,
-                    ),
-                )
-            )
-    # Enforce a deterministic ordering: first by created_at, then by id.
-    query = query.order_by(AgentModel.created_at.asc(), AgentModel.id.asc())
+            query = query.where(_cursor_filter(AgentModel.created_at, AgentModel.id, before_created_at, before_id, forward=not ascending))
+
+    # Apply ordering
+    order_fn = asc if ascending else desc
+    query = query.order_by(order_fn(AgentModel.created_at), order_fn(AgentModel.id))
     return query
 
 

letta/services/message_manager.py

@@ -1,5 +1,5 @@
 import json
-from typing import List, Optional
+from typing import List, Optional, Sequence
 
 from sqlalchemy import and_, exists, func, or_, select, text
 
@@ -248,7 +248,7 @@ class MessageManager:
             after=after,
             before=before,
             query_text=query_text,
-            role=MessageRole.user,
+            roles=[MessageRole.user],
             limit=limit,
             ascending=ascending,
         )
@@ -261,7 +261,7 @@ class MessageManager:
         after: Optional[str] = None,
         before: Optional[str] = None,
         query_text: Optional[str] = None,
-        role: Optional[MessageRole] = None,  # New parameter for filtering by role
+        roles: Optional[Sequence[MessageRole]] = None,
         limit: Optional[int] = 50,
         ascending: bool = True,
     ) -> List[PydanticMessage]:
@@ -279,7 +279,7 @@ class MessageManager:
             after: A message ID; if provided, only messages *after* this message (per sort order) are returned.
             before: A message ID; if provided, only messages *before* this message are returned.
             query_text: Optional string to partially match the message text content.
-            role: Optional MessageRole to filter messages by role.
+            roles: Optional MessageRole to filter messages by role.
             limit: Maximum number of messages to return.
             ascending: If True, sort by (created_at, id) ascending; if False, sort descending.
 
@@ -309,8 +309,9 @@ class MessageManager:
                 )
 
             # If role is provided, filter messages by role.
-            if role:
-                query = query.filter(MessageModel.role == role.value)  # Enum.value ensures comparison is against the string value
+            if roles:
+                role_values = [r.value for r in roles]
+                query = query.filter(MessageModel.role.in_(role_values))
 
             # Apply 'after' pagination if specified.
             if after:

letta/services/organization_manager.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.schemas.organization import Organization as PydanticOrganization
+from letta.schemas.organization import OrganizationUpdate
 from letta.utils import enforce_types
 
 
@@ -63,6 +64,18 @@ class OrganizationManager:
             org.update(session)
             return org.to_pydantic()
 
+    @enforce_types
+    def update_organization(self, org_id: str, org_update: OrganizationUpdate) -> PydanticOrganization:
+        """Update an organization."""
+        with self.session_maker() as session:
+            org = OrganizationModel.read(db_session=session, identifier=org_id)
+            if org_update.name:
+                org.name = org_update.name
+            if org_update.privileged_tools:
+                org.privileged_tools = org_update.privileged_tools
+            org.update(session)
+            return org.to_pydantic()
+
     @enforce_types
     def delete_organization_by_id(self, org_id: str):
         """Delete an organization by marking it as deleted."""

letta/services/tool_execution_sandbox.py

@@ -23,6 +23,7 @@ from letta.services.helpers.tool_execution_helper import (
     find_python_executable,
     install_pip_requirements_for_sandbox,
 )
+from letta.services.organization_manager import OrganizationManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
 from letta.settings import tool_settings
@@ -50,6 +51,9 @@ class ToolExecutionSandbox:
         self.tool_name = tool_name
         self.args = args
         self.user = user
+        # get organization
+        self.organization = OrganizationManager().get_organization_by_id(self.user.organization_id)
+        self.privileged_tools = self.organization.privileged_tools
 
         # If a tool object is provided, we use it directly, otherwise pull via name
         if tool_object is not None:
@@ -79,7 +83,7 @@ class ToolExecutionSandbox:
         Returns:
             Tuple[Any, Optional[AgentState]]: Tuple containing (tool_result, agent_state)
         """
-        if tool_settings.e2b_api_key:
+        if tool_settings.e2b_api_key and not self.privileged_tools:
             logger.debug(f"Using e2b sandbox to execute {self.tool_name}")
             result = self.run_e2b_sandbox(agent_state=agent_state, additional_env_vars=additional_env_vars)
         else:

letta/services/tool_executor/tool_execution_manager.py

@@ -0,0 +1,74 @@
+from typing import Any, Dict, Optional, Tuple, Type
+
+from letta.log import get_logger
+from letta.orm.enums import ToolType
+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_executor.tool_executor import (
+    ExternalComposioToolExecutor,
+    ExternalMCPToolExecutor,
+    LettaCoreToolExecutor,
+    LettaMemoryToolExecutor,
+    LettaMultiAgentToolExecutor,
+    SandboxToolExecutor,
+    ToolExecutor,
+)
+from letta.utils import get_friendly_error_msg
+
+
+class ToolExecutorFactory:
+    """Factory for creating appropriate tool executors based on tool type."""
+
+    _executor_map: Dict[ToolType, Type[ToolExecutor]] = {
+        ToolType.LETTA_CORE: LettaCoreToolExecutor,
+        ToolType.LETTA_MULTI_AGENT_CORE: LettaMultiAgentToolExecutor,
+        ToolType.LETTA_MEMORY_CORE: LettaMemoryToolExecutor,
+        ToolType.EXTERNAL_COMPOSIO: ExternalComposioToolExecutor,
+        ToolType.EXTERNAL_MCP: ExternalMCPToolExecutor,
+    }
+
+    @classmethod
+    def get_executor(cls, tool_type: ToolType) -> ToolExecutor:
+        """Get the appropriate executor for the given tool type."""
+        executor_class = cls._executor_map.get(tool_type)
+
+        if executor_class:
+            return executor_class()
+
+        # Default to sandbox executor for unknown types
+        return SandboxToolExecutor()
+
+
+class ToolExecutionManager:
+    """Manager class for tool execution operations."""
+
+    def __init__(self, agent_state: AgentState, actor: User):
+        self.agent_state = agent_state
+        self.logger = get_logger(__name__)
+        self.actor = actor
+
+    def execute_tool(self, function_name: str, function_args: dict, tool: Tool) -> Tuple[Any, Optional[SandboxRunResult]]:
+        """
+        Execute a tool and persist any state changes.
+
+        Args:
+            function_name: Name of the function to execute
+            function_args: Arguments to pass to the function
+            tool: Tool object containing metadata about the tool
+
+        Returns:
+            Tuple containing the function response and sandbox run result (if applicable)
+        """
+        try:
+            # Get the appropriate executor for this tool type
+            executor = ToolExecutorFactory.get_executor(tool.tool_type)
+
+            # Execute the tool
+            return executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
+
+        except Exception as e:
+            self.logger.error(f"Error executing tool {function_name}: {str(e)}")
+            error_message = get_friendly_error_msg(function_name=function_name, exception_name=type(e).__name__, exception_message=str(e))
+            return error_message, SandboxRunResult(status="error")