letta-nightly 0.6.43.dev20250320104204__py3-none-any.whl → 0.6.43.dev20250321104124__py3-none-any.whl

letta/functions/helpers.py

@@ -93,7 +93,7 @@ def execute_composio_action(
 
     entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
     try:
-        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id)
+        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
         response = composio_toolset.execute_action(action=action_name, params=args)
     except ApiKeyNotProvidedError:
         raise RuntimeError(
@@ -533,57 +533,17 @@ def fire_and_forget_send_to_agent(
 
 
 async def _send_message_to_agents_matching_tags_async(
-    sender_agent: "Agent", message: str, match_all: List[str], match_some: List[str]
+    sender_agent: "Agent", server: "SyncServer", messages: List[MessageCreate], matching_agents: List["AgentState"]
 ) -> List[str]:
-    log_telemetry(
-        sender_agent.logger,
-        "_send_message_to_agents_matching_tags_async start",
-        message=message,
-        match_all=match_all,
-        match_some=match_some,
-    )
-    server = get_letta_server()
-
-    augmented_message = (
-        f"[Incoming message from agent with ID '{sender_agent.agent_state.id}' - to reply to this message, "
-        f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
-        f"{message}"
-    )
-
-    # Retrieve up to 100 matching agents
-    log_telemetry(
-        sender_agent.logger,
-        "_send_message_to_agents_matching_tags_async listing agents start",
-        message=message,
-        match_all=match_all,
-        match_some=match_some,
-    )
-    matching_agents = server.agent_manager.list_agents_matching_tags(actor=sender_agent.user, match_all=match_all, match_some=match_some)
-
-    log_telemetry(
-        sender_agent.logger,
-        "_send_message_to_agents_matching_tags_async  listing agents finish",
-        message=message,
-        match_all=match_all,
-        match_some=match_some,
-    )
-
-    # Create a system message
-    messages = [MessageCreate(role=MessageRole.system, content=augmented_message, name=sender_agent.agent_state.name)]
-
-    # Possibly limit concurrency to avoid meltdown:
-    sem = asyncio.Semaphore(settings.multi_agent_concurrent_sends)
-
     async def _send_single(agent_state):
-        async with sem:
-            return await async_send_message_with_retries(
-                server=server,
-                sender_agent=sender_agent,
-                target_agent_id=agent_state.id,
-                messages=messages,
-                max_retries=3,
-                timeout=settings.multi_agent_send_message_timeout,
-            )
+        return await async_send_message_with_retries(
+            server=server,
+            sender_agent=sender_agent,
+            target_agent_id=agent_state.id,
+            messages=messages,
+            max_retries=3,
+            timeout=settings.multi_agent_send_message_timeout,
+        )
 
     tasks = [asyncio.create_task(_send_single(agent_state)) for agent_state in matching_agents]
     results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -594,13 +554,6 @@ async def _send_message_to_agents_matching_tags_async(
         else:
             final.append(r)
 
-    log_telemetry(
-        sender_agent.logger,
-        "_send_message_to_agents_matching_tags_async finish",
-        message=message,
-        match_all=match_all,
-        match_some=match_some,
-    )
     return final
 
 

letta/functions/mcp_client/base_client.py

@@ -1,9 +1,10 @@
 import asyncio
 from typing import List, Optional, Tuple
 
-from mcp import ClientSession, Tool
+from mcp import ClientSession
 
-from letta.functions.mcp_client.types import BaseServerConfig
+from letta.functions.mcp_client.exceptions import MCPTimeoutError
+from letta.functions.mcp_client.types import BaseServerConfig, MCPTool
 from letta.log import get_logger
 from letta.settings import tool_settings
 
@@ -31,9 +32,7 @@ class BaseMCPClient:
                 )
                 self.initialized = True
             except asyncio.TimeoutError:
-                raise RuntimeError(
-                    f"Timed out while initializing session for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_connect_to_server_timeout}s)."
-                )
+                raise MCPTimeoutError("initializing session", self.server_config.server_name, tool_settings.mcp_connect_to_server_timeout)
         else:
             raise RuntimeError(
                 f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
@@ -42,7 +41,7 @@ class BaseMCPClient:
     def _initialize_connection(self, server_config: BaseServerConfig, timeout: float) -> bool:
         raise NotImplementedError("Subclasses must implement _initialize_connection")
 
-    def list_tools(self) -> List[Tool]:
+    def list_tools(self) -> List[MCPTool]:
         self._check_initialized()
         try:
             response = self.loop.run_until_complete(
@@ -50,11 +49,10 @@ class BaseMCPClient:
             )
             return response.tools
         except asyncio.TimeoutError:
-            # Could log, throw a custom exception, etc.
             logger.error(
                 f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
             )
-            return []
+            raise MCPTimeoutError("listing tools", self.server_config.server_name, tool_settings.mcp_list_tools_timeout)
 
     def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
         self._check_initialized()
@@ -67,7 +65,7 @@ class BaseMCPClient:
             logger.error(
                 f"Timed out while executing tool '{tool_name}' for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_execute_tool_timeout}s)."
             )
-            return "", True
+            raise MCPTimeoutError(f"executing tool '{tool_name}'", self.server_config.server_name, tool_settings.mcp_execute_tool_timeout)
 
     def _check_initialized(self):
         if not self.initialized:

letta/functions/mcp_client/exceptions.py

@@ -0,0 +1,6 @@
+class MCPTimeoutError(RuntimeError):
+    """Custom exception raised when an MCP operation times out."""
+
+    def __init__(self, operation: str, server_name: str, timeout: float):
+        message = f"Timed out while {operation} for MCP server {server_name} (timeout={timeout}s)."
+        super().__init__(message)

letta/helpers/tool_execution_helper.py

@@ -36,11 +36,10 @@ def enable_strict_mode(tool_schema: Dict[str, Any]) -> Dict[str, Any]:
         # Set additionalProperties to False
         parameters["additionalProperties"] = False
         schema["parameters"] = parameters
-
     return schema
 
 
-def add_pre_execution_message(tool_schema: Dict[str, Any]) -> Dict[str, Any]:
+def add_pre_execution_message(tool_schema: Dict[str, Any], description: Optional[str] = None) -> Dict[str, Any]:
     """Adds a `pre_execution_message` parameter to a tool schema to prompt a natural, human-like message before executing the tool.
 
     Args:
@@ -58,14 +57,17 @@ def add_pre_execution_message(tool_schema: Dict[str, Any]) -> Dict[str, Any]:
     properties = parameters.get("properties", {})
     required = parameters.get("required", [])
 
-    # Define the new `pre_execution_message` field with a refined description
-    pre_execution_message_field = {
-        "type": "string",
-        "description": (
+    # Define the new `pre_execution_message` field
+    if not description:
+        # Default description
+        description = (
             "A concise message to be uttered before executing this tool. "
             "This should sound natural, as if a person is casually announcing their next action."
             "You MUST also include punctuation at the end of this message."
-        ),
+        )
+    pre_execution_message_field = {
+        "type": "string",
+        "description": description,
     }
 
     # Ensure the pre-execution message is the first field in properties

letta/llm_api/anthropic.py

@@ -606,25 +606,6 @@ def _prepare_anthropic_request(
         # TODO eventually enable parallel tool use
         data["tools"] = anthropic_tools
 
-        # tool_choice_type other than "auto" only plays nice if thinking goes inside the tool calls
-        if put_inner_thoughts_in_kwargs:
-            if len(anthropic_tools) == 1:
-                data["tool_choice"] = {
-                    "type": "tool",
-                    "name": anthropic_tools[0]["name"],
-                    "disable_parallel_tool_use": True,
-                }
-            else:
-                data["tool_choice"] = {
-                    "type": "any",
-                    "disable_parallel_tool_use": True,
-                }
-        else:
-            data["tool_choice"] = {
-                "type": "auto",
-                "disable_parallel_tool_use": True,
-            }
-
     # Move 'system' to the top level
     assert data["messages"][0]["role"] == "system", f"Expected 'system' role in messages[0]:\n{data['messages'][0]}"
     data["system"] = data["messages"][0]["content"]
@@ -720,6 +701,7 @@ def anthropic_bedrock_chat_completions_request(
     # Make the request
     try:
         # bedrock does not support certain args
+        print("Warning: Tool rules not supported with Anthropic Bedrock")
         data["tool_choice"] = {"type": "any"}
         log_event(name="llm_request_sent", attributes=data)
         response = client.messages.create(**data)

letta/llm_api/aws_bedrock.py

@@ -13,7 +13,7 @@ def has_valid_aws_credentials() -> bool:
     """
     Check if AWS credentials are properly configured.
     """
-    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY") and os.getenv("AWS_SECRET_ACCESS_KEY") and os.getenv("AWS_REGION")
+    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY") is not None and os.getenv("AWS_SECRET_ACCESS_KEY") is not None and os.getenv("AWS_REGION") is not None
     return valid_aws_credentials
 
 
@@ -78,7 +78,7 @@ def bedrock_get_model_details(region_name: str, model_id: str) -> Dict[str, Any]
         response = bedrock.get_foundation_model(modelIdentifier=model_id)
         return response["modelDetails"]
     except ClientError as e:
-        logger.exception(f"Error getting model details: {str(e)}", e)
+        logger.exception(f"Error getting model details: {str(e)}")
         raise e
 
 

letta/llm_api/azure_openai.py

@@ -1,14 +1,14 @@
 from collections import defaultdict
 
 import requests
+from openai import AzureOpenAI
 
-from letta.llm_api.helpers import make_post_request
+
+from letta.llm_api.openai import prepare_openai_payload
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.schemas.openai.chat_completions import ChatCompletionRequest
-from letta.schemas.openai.embedding_response import EmbeddingResponse
 from letta.settings import ModelSettings
-from letta.tracing import log_event
 
 
 def get_azure_chat_completions_endpoint(base_url: str, model: str, api_version: str):
@@ -33,19 +33,19 @@ def get_azure_deployment_list_endpoint(base_url: str):
 def azure_openai_get_deployed_model_list(base_url: str, api_key: str, api_version: str) -> list:
     """https://learn.microsoft.com/en-us/rest/api/azureopenai/models/list?view=rest-azureopenai-2023-05-15&tabs=HTTP"""
 
-    # https://xxx.openai.azure.com/openai/models?api-version=xxx
-    headers = {"Content-Type": "application/json"}
-    if api_key is not None:
-        headers["api-key"] = f"{api_key}"
+    client = AzureOpenAI(api_key=api_key, api_version=api_version, azure_endpoint=base_url)
 
-    # 1. Get all available models
-    url = get_azure_model_list_endpoint(base_url, api_version)
     try:
-        response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        models_list = client.models.list()
     except requests.RequestException as e:
         raise RuntimeError(f"Failed to retrieve model list: {e}")
-    all_available_models = response.json().get("data", [])
+
+    all_available_models = [model.to_dict() for model in models_list.data]
+
+    # https://xxx.openai.azure.com/openai/models?api-version=xxx
+    headers = {"Content-Type": "application/json"}
+    if api_key is not None:
+        headers["api-key"] = f"{api_key}"
 
     # 2. Get all the deployed models
     url = get_azure_deployment_list_endpoint(base_url)
@@ -102,42 +102,18 @@ def azure_openai_get_embeddings_model_list(base_url: str, api_key: str, api_vers
 
 
 def azure_openai_chat_completions_request(
-    model_settings: ModelSettings, llm_config: LLMConfig, api_key: str, chat_completion_request: ChatCompletionRequest
+    model_settings: ModelSettings, llm_config: LLMConfig, chat_completion_request: ChatCompletionRequest
 ) -> ChatCompletionResponse:
     """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#chat-completions"""
 
-    assert api_key is not None, "Missing required field when calling Azure OpenAI"
-
-    headers = {"Content-Type": "application/json", "api-key": f"{api_key}"}
-    data = chat_completion_request.model_dump(exclude_none=True)
-
-    # If functions == None, strip from the payload
-    if "functions" in data and data["functions"] is None:
-        data.pop("functions")
-        data.pop("function_call", None)  # extra safe,  should exist always (default="auto")
-
-    if "tools" in data and data["tools"] is None:
-        data.pop("tools")
-        data.pop("tool_choice", None)  # extra safe,  should exist always (default="auto")
-
-    url = get_azure_chat_completions_endpoint(model_settings.azure_base_url, llm_config.model, model_settings.azure_api_version)
-    log_event(name="llm_request_sent", attributes=data)
-    response_json = make_post_request(url, headers, data)
-    # NOTE: azure openai does not include "content" in the response when it is None, so we need to add it
-    if "content" not in response_json["choices"][0].get("message"):
-        response_json["choices"][0]["message"]["content"] = None
-    log_event(name="llm_response_received", attributes=response_json)
-    response = ChatCompletionResponse(**response_json)  # convert to 'dot-dict' style which is the openai python client default
-    return response
-
-
-def azure_openai_embeddings_request(
-    resource_name: str, deployment_id: str, api_version: str, api_key: str, data: dict
-) -> EmbeddingResponse:
-    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings"""
+    assert model_settings.azure_api_key is not None, "Missing required api key field when calling Azure OpenAI"
+    assert model_settings.azure_api_version is not None, "Missing required api version field when calling Azure OpenAI"
+    assert model_settings.azure_base_url is not None, "Missing required base url field when calling Azure OpenAI"
 
-    url = f"https://{resource_name}.openai.azure.com/openai/deployments/{deployment_id}/embeddings?api-version={api_version}"
-    headers = {"Content-Type": "application/json", "api-key": f"{api_key}"}
+    data = prepare_openai_payload(chat_completion_request)
+    client = AzureOpenAI(
+        api_key=model_settings.azure_api_key, api_version=model_settings.azure_api_version, azure_endpoint=model_settings.azure_base_url
+    )
+    chat_completion = client.chat.completions.create(**data)
 
-    response_json = make_post_request(url, headers, data)
-    return EmbeddingResponse(**response_json)
+    return ChatCompletionResponse(**chat_completion.model_dump())

letta/llm_api/llm_api_tools.py

@@ -306,7 +306,6 @@ def create(
         response = azure_openai_chat_completions_request(
             model_settings=model_settings,
             llm_config=llm_config,
-            api_key=model_settings.azure_api_key,
             chat_completion_request=chat_completion_request,
         )
 
@@ -374,14 +373,26 @@ def create(
         # Force tool calling
         tool_call = None
         if force_tool_call is not None:
-            tool_call = {"type": "function", "function": {"name": force_tool_call}}
+            # tool_call = {"type": "function", "function": {"name": force_tool_call}}
+            tool_choice = {"type": "tool", "name": force_tool_call}
+            tools = [{"type": "function", "function": f} for f in functions if f["name"] == force_tool_call]
             assert functions is not None
 
+            # need to have this setting to be able to put inner thoughts in kwargs
+            llm_config.put_inner_thoughts_in_kwargs = True
+        else:
+            if llm_config.put_inner_thoughts_in_kwargs:
+                # tool_choice_type other than "auto" only plays nice if thinking goes inside the tool calls
+                tool_choice = {"type": "any", "disable_parallel_tool_use": True}
+            else:
+                tool_choice = {"type": "auto", "disable_parallel_tool_use": True}
+            tools = [{"type": "function", "function": f} for f in functions]
+
         chat_completion_request = ChatCompletionRequest(
             model=llm_config.model,
             messages=[cast_message_to_subtype(m.to_openai_dict()) for m in messages],
-            tools=([{"type": "function", "function": f} for f in functions] if functions else None),
-            tool_choice=tool_call,
+            tools=tools,
+            tool_choice=tool_choice,
             max_tokens=llm_config.max_tokens,  # Note: max_tokens is required for Anthropic API
             temperature=llm_config.temperature,
             stream=stream,

letta/orm/sqlalchemy_base.py

@@ -286,7 +286,45 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         Raises:
             NoResultFound: if the object is not found
         """
-        logger.debug(f"Reading {cls.__name__} with ID: {identifier} with actor={actor}")
+        # this is ok because read_multiple will check if the
+        identifiers = [] if identifier is None else [identifier]
+        found = cls.read_multiple(db_session, identifiers, actor, access, access_type, **kwargs)
+        if len(found) == 0:
+            # for backwards compatibility.
+            conditions = []
+            if identifier:
+                conditions.append(f"id={identifier}")
+            if actor:
+                conditions.append(f"access level in {access} for {actor}")
+            if hasattr(cls, "is_deleted"):
+                conditions.append("is_deleted=False")
+            raise NoResultFound(f"{cls.__name__} not found with {', '.join(conditions if conditions else ['no conditions'])}")
+        return found[0]
+
+    @classmethod
+    @handle_db_timeout
+    def read_multiple(
+        cls,
+        db_session: "Session",
+        identifiers: List[str] = [],
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        **kwargs,
+    ) -> List["SqlalchemyBase"]:
+        """The primary accessor for ORM record(s)
+        Args:
+            db_session: the database session to use when retrieving the record
+            identifiers: a list of identifiers of the records to read, can be the id string or the UUID object for backwards compatibility
+            actor: if specified, results will be scoped only to records the user is able to access
+            access: if actor is specified, records will be filtered to the minimum permission level for the actor
+            kwargs: additional arguments to pass to the read, used for more complex objects
+        Returns:
+            The matching object
+        Raises:
+            NoResultFound: if the object is not found
+        """
+        logger.debug(f"Reading {cls.__name__} with ID(s): {identifiers} with actor={actor}")
 
         # Start the query
         query = select(cls)
@@ -294,9 +332,9 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         query_conditions = []
 
         # If an identifier is provided, add it to the query conditions
-        if identifier is not None:
-            query = query.where(cls.id == identifier)
-            query_conditions.append(f"id='{identifier}'")
+        if len(identifiers) > 0:
+            query = query.where(cls.id.in_(identifiers))
+            query_conditions.append(f"id='{identifiers}'")
 
         if kwargs:
             query = query.filter_by(**kwargs)
@@ -309,12 +347,29 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         if hasattr(cls, "is_deleted"):
             query = query.where(cls.is_deleted == False)
             query_conditions.append("is_deleted=False")
-        if found := db_session.execute(query).scalar():
-            return found
+
+        results = db_session.execute(query).scalars().all()
+        if results:  # if empty list a.k.a. no results
+            if len(identifiers) > 0:
+                # find which identifiers were not found
+                # only when identifier length is greater than 0 (so it was used in the actual query)
+                identifier_set = set(identifiers)
+                results_set = set(map(lambda obj: obj.id, results))
+
+                # we log a warning message if any of the queried IDs were not found.
+                # TODO: should we error out instead?
+                if identifier_set != results_set:
+                    # Construct a detailed error message based on query conditions
+                    conditions_str = ", ".join(query_conditions) if query_conditions else "no specific conditions"
+                    logger.warning(
+                        f"{cls.__name__} not found with {conditions_str}. Queried ids: {identifier_set}, Found ids: {results_set}"
+                    )
+            return results
 
         # Construct a detailed error message based on query conditions
         conditions_str = ", ".join(query_conditions) if query_conditions else "no specific conditions"
-        raise NoResultFound(f"{cls.__name__} not found with {conditions_str}")
+        logger.warning(f"{cls.__name__} not found with {conditions_str}")
+        return []
 
     @handle_db_timeout
     def create(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
@@ -331,6 +386,50 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         except (DBAPIError, IntegrityError) as e:
             self._handle_dbapi_error(e)
 
+    @classmethod
+    @handle_db_timeout
+    def batch_create(cls, items: List["SqlalchemyBase"], db_session: "Session", actor: Optional["User"] = None) -> List["SqlalchemyBase"]:
+        """
+        Create multiple records in a single transaction for better performance.
+
+        Args:
+            items: List of model instances to create
+            db_session: SQLAlchemy session
+            actor: Optional user performing the action
+
+        Returns:
+            List of created model instances
+        """
+        logger.debug(f"Batch creating {len(items)} {cls.__name__} items with actor={actor}")
+
+        if not items:
+            return []
+
+        # Set created/updated by fields if actor is provided
+        if actor:
+            for item in items:
+                item._set_created_and_updated_by_fields(actor.id)
+
+        try:
+            with db_session as session:
+                session.add_all(items)
+                session.flush()  # Flush to generate IDs but don't commit yet
+
+                # Collect IDs to fetch the complete objects after commit
+                item_ids = [item.id for item in items]
+
+                session.commit()
+
+                # Re-query the objects to get them with relationships loaded
+                query = select(cls).where(cls.id.in_(item_ids))
+                if hasattr(cls, "created_at"):
+                    query = query.order_by(cls.created_at)
+
+                return list(session.execute(query).scalars())
+
+        except (DBAPIError, IntegrityError) as e:
+            cls._handle_dbapi_error(e)
+
     @handle_db_timeout
     def delete(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
         logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")

letta/schemas/openai/chat_completion_request.py

@@ -74,7 +74,25 @@ class ToolFunctionChoice(BaseModel):
     function: FunctionCall
 
 
-ToolChoice = Union[Literal["none", "auto", "required"], ToolFunctionChoice]
+class AnthropicToolChoiceTool(BaseModel):
+    type: str = "tool"
+    name: str
+    disable_parallel_tool_use: Optional[bool] = False
+
+
+class AnthropicToolChoiceAny(BaseModel):
+    type: str = "any"
+    disable_parallel_tool_use: Optional[bool] = False
+
+
+class AnthropicToolChoiceAuto(BaseModel):
+    type: str = "auto"
+    disable_parallel_tool_use: Optional[bool] = False
+
+
+ToolChoice = Union[
+    Literal["none", "auto", "required", "any"], ToolFunctionChoice, AnthropicToolChoiceTool, AnthropicToolChoiceAny, AnthropicToolChoiceAuto
+]
 
 
 ## tools ##
@@ -82,6 +100,7 @@ class FunctionSchema(BaseModel):
     name: str
     description: Optional[str] = None
     parameters: Optional[Dict[str, Any]] = None  # JSON Schema for the parameters
+    strict: bool = False
 
 
 class Tool(BaseModel):