letta-nightly 0.6.41.dev20250317104157__py3-none-any.whl → 0.6.43.dev20250318012126__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -367,7 +367,10 @@ class Agent(BaseAgent):
     ) -> ChatCompletionResponse:
         """Get response from LLM API with robust retry mechanism."""
         log_telemetry(self.logger, "_get_ai_reply start")
-        allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names(last_function_response=self.last_function_response)
+        available_tools = set([t.name for t in self.agent_state.tools])
+        allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names(
+            available_tools=available_tools, last_function_response=self.last_function_response
+        )
         agent_state_tool_jsons = [t.json_schema for t in self.agent_state.tools]
 
         allowed_functions = (
@@ -377,8 +380,8 @@ class Agent(BaseAgent):
         )
 
         # Don't allow a tool to be called if it failed last time
-        if last_function_failed and self.tool_rules_solver.last_tool_name:
-            allowed_functions = [f for f in allowed_functions if f["name"] != self.tool_rules_solver.last_tool_name]
+        if last_function_failed and self.tool_rules_solver.tool_call_history:
+            allowed_functions = [f for f in allowed_functions if f["name"] != self.tool_rules_solver.tool_call_history[-1]]
             if not allowed_functions:
                 return None
 
@@ -773,6 +776,11 @@ class Agent(BaseAgent):
         **kwargs,
     ) -> LettaUsageStatistics:
         """Run Agent.step in a loop, handling chaining via heartbeat requests and function failures"""
+        # Defensively clear the tool rules solver history
+        # Usually this would be extraneous as Agent loop is re-loaded on every message send
+        # But just to be safe
+        self.tool_rules_solver.clear_tool_history()
+
         next_input_message = messages if isinstance(messages, list) else [messages]
         counter = 0
         total_usage = UsageStatistics()

letta/embeddings.py

@@ -3,6 +3,7 @@ from typing import Any, List, Optional
 
 import numpy as np
 import tiktoken
+from openai import OpenAI
 
 from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP, MAX_EMBEDDING_DIM
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -201,6 +202,21 @@ class GoogleVertexEmbeddings:
         return response.embeddings[0].embedding
 
 
+class OpenAIEmbeddings:
+
+    def __init__(self, api_key: str, model: str, base_url: str):
+        if base_url:
+            self.client = OpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.client = OpenAI(api_key=api_key)
+        self.model = model
+
+    def get_text_embedding(self, text: str):
+        response = self.client.embeddings.create(input=text, model=self.model)
+
+        return response.data[0].embedding
+
+
 def query_embedding(embedding_model, query_text: str):
     """Generate padded embedding for querying database"""
     query_vec = embedding_model.get_text_embedding(query_text)
@@ -218,15 +234,9 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
     from letta.settings import model_settings
 
     if endpoint_type == "openai":
-        from llama_index.embeddings.openai import OpenAIEmbedding
-
-        additional_kwargs = {"user_id": user_id} if user_id else {}
-        model = OpenAIEmbedding(
-            api_base=config.embedding_endpoint,
-            api_key=model_settings.openai_api_key,
-            additional_kwargs=additional_kwargs,
+        return OpenAIEmbeddings(
+            api_key=model_settings.openai_api_key, model=config.embedding_model, base_url=model_settings.openai_api_base
         )
-        return model
 
     elif endpoint_type == "azure":
         assert all(

letta/functions/mcp_client/base_client.py

@@ -5,12 +5,14 @@ from mcp import ClientSession, Tool
 
 from letta.functions.mcp_client.types import BaseServerConfig
 from letta.log import get_logger
+from letta.settings import tool_settings
 
 logger = get_logger(__name__)
 
 
 class BaseMCPClient:
-    def __init__(self):
+    def __init__(self, server_config: BaseServerConfig):
+        self.server_config = server_config
         self.session: Optional[ClientSession] = None
         self.stdio = None
         self.write = None
@@ -18,30 +20,54 @@ class BaseMCPClient:
         self.loop = asyncio.new_event_loop()
         self.cleanup_funcs = []
 
-    def connect_to_server(self, server_config: BaseServerConfig):
+    def connect_to_server(self):
         asyncio.set_event_loop(self.loop)
-        success = self._initialize_connection(server_config)
+        success = self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
 
         if success:
-            self.loop.run_until_complete(self.session.initialize())
-            self.initialized = True
+            try:
+                self.loop.run_until_complete(
+                    asyncio.wait_for(self.session.initialize(), timeout=tool_settings.mcp_connect_to_server_timeout)
+                )
+                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)."
+                )
         else:
             raise RuntimeError(
-                f"Connecting to MCP server failed. Please review your server config: {server_config.model_dump_json(indent=4)}"
+                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
             )
 
-    def _initialize_connection(self, server_config: BaseServerConfig) -> bool:
+    def _initialize_connection(self, server_config: BaseServerConfig, timeout: float) -> bool:
         raise NotImplementedError("Subclasses must implement _initialize_connection")
 
     def list_tools(self) -> List[Tool]:
         self._check_initialized()
-        response = self.loop.run_until_complete(self.session.list_tools())
-        return response.tools
+        try:
+            response = self.loop.run_until_complete(
+                asyncio.wait_for(self.session.list_tools(), timeout=tool_settings.mcp_list_tools_timeout)
+            )
+            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 []
 
     def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
         self._check_initialized()
-        result = self.loop.run_until_complete(self.session.call_tool(tool_name, tool_args))
-        return str(result.content), result.isError
+        try:
+            result = self.loop.run_until_complete(
+                asyncio.wait_for(self.session.call_tool(tool_name, tool_args), timeout=tool_settings.mcp_execute_tool_timeout)
+            )
+            return str(result.content), result.isError
+        except asyncio.TimeoutError:
+            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
 
     def _check_initialized(self):
         if not self.initialized:

letta/functions/mcp_client/sse_client.py

@@ -1,21 +1,33 @@
+import asyncio
+
 from mcp import ClientSession
 from mcp.client.sse import sse_client
 
 from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
 
 # see: https://modelcontextprotocol.io/quickstart/user
 MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
 
+logger = get_logger(__name__)
+
 
 class SSEMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: SSEServerConfig) -> bool:
-        sse_cm = sse_client(url=server_config.server_url)
-        sse_transport = self.loop.run_until_complete(sse_cm.__aenter__())
-        self.stdio, self.write = sse_transport
-        self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
+    def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
+        try:
+            sse_cm = sse_client(url=server_config.server_url)
+            sse_transport = self.loop.run_until_complete(asyncio.wait_for(sse_cm.__aenter__(), timeout=timeout))
+            self.stdio, self.write = sse_transport
+            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
 
-        session_cm = ClientSession(self.stdio, self.write)
-        self.session = self.loop.run_until_complete(session_cm.__aenter__())
-        self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
-        return True
+            session_cm = ClientSession(self.stdio, self.write)
+            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
+            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
+            return True
+        except asyncio.TimeoutError:
+            logger.error(f"Timed out while establishing SSE connection (timeout={timeout}s).")
+            return False
+        except Exception:
+            logger.exception("Exception occurred while initializing SSE client session.")
+            return False

letta/functions/mcp_client/stdio_client.py

@@ -1,3 +1,4 @@
+import asyncio
 import sys
 from contextlib import asynccontextmanager
 
@@ -16,19 +17,23 @@ logger = get_logger(__name__)
 
 
 class StdioMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: StdioServerConfig) -> bool:
+    def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
         try:
             server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
             stdio_cm = forked_stdio_client(server_params)
-            stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())
+            stdio_transport = self.loop.run_until_complete(asyncio.wait_for(stdio_cm.__aenter__(), timeout=timeout))
             self.stdio, self.write = stdio_transport
             self.cleanup_funcs.append(lambda: self.loop.run_until_complete(stdio_cm.__aexit__(None, None, None)))
 
             session_cm = ClientSession(self.stdio, self.write)
-            self.session = self.loop.run_until_complete(session_cm.__aenter__())
+            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
             self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
             return True
+        except asyncio.TimeoutError:
+            logger.error(f"Timed out while establishing stdio connection (timeout={timeout}s).")
+            return False
         except Exception:
+            logger.exception("Exception occurred while initializing stdio client session.")
             return False
 
 

letta/helpers/converters.py

@@ -20,7 +20,15 @@ from letta.schemas.letta_message_content import (
 )
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import ToolReturn
-from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule, ToolRule
+from letta.schemas.tool_rule import (
+    ChildToolRule,
+    ConditionalToolRule,
+    ContinueToolRule,
+    InitToolRule,
+    MaxCountPerStepToolRule,
+    TerminalToolRule,
+    ToolRule,
+)
 
 # --------------------------
 # LLMConfig Serialization
@@ -85,23 +93,27 @@ def deserialize_tool_rules(data: Optional[List[Dict]]) -> List[Union[ChildToolRu
     return [deserialize_tool_rule(rule_data) for rule_data in data]
 
 
-def deserialize_tool_rule(data: Dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule]:
+def deserialize_tool_rule(
+    data: Dict,
+) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule]:
     """Deserialize a dictionary to the appropriate ToolRule subclass based on 'type'."""
     rule_type = ToolRuleType(data.get("type"))
 
-    if rule_type == ToolRuleType.run_first or rule_type == ToolRuleType.InitToolRule:
+    if rule_type == ToolRuleType.run_first:
         data["type"] = ToolRuleType.run_first
         return InitToolRule(**data)
-    elif rule_type == ToolRuleType.exit_loop or rule_type == ToolRuleType.TerminalToolRule:
+    elif rule_type == ToolRuleType.exit_loop:
         data["type"] = ToolRuleType.exit_loop
         return TerminalToolRule(**data)
-    elif rule_type == ToolRuleType.constrain_child_tools or rule_type == ToolRuleType.ToolRule:
+    elif rule_type == ToolRuleType.constrain_child_tools:
         data["type"] = ToolRuleType.constrain_child_tools
         return ChildToolRule(**data)
     elif rule_type == ToolRuleType.conditional:
         return ConditionalToolRule(**data)
     elif rule_type == ToolRuleType.continue_loop:
         return ContinueToolRule(**data)
+    elif rule_type == ToolRuleType.max_count_per_step:
+        return MaxCountPerStepToolRule(**data)
     raise ValueError(f"Unknown ToolRule type: {rule_type}")
 
 

letta/helpers/tool_rule_solver.py

@@ -1,10 +1,17 @@
-import json
-from typing import List, Optional, Union
+from typing import List, Optional, Set, Union
 
 from pydantic import BaseModel, Field
 
 from letta.schemas.enums import ToolRuleType
-from letta.schemas.tool_rule import BaseToolRule, ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule
+from letta.schemas.tool_rule import (
+    BaseToolRule,
+    ChildToolRule,
+    ConditionalToolRule,
+    ContinueToolRule,
+    InitToolRule,
+    MaxCountPerStepToolRule,
+    TerminalToolRule,
+)
 
 
 class ToolRuleValidationError(Exception):
@@ -21,13 +28,15 @@ class ToolRulesSolver(BaseModel):
     continue_tool_rules: List[ContinueToolRule] = Field(
         default_factory=list, description="Continue tool rules to be used to continue tool execution."
     )
-    tool_rules: List[Union[ChildToolRule, ConditionalToolRule]] = Field(
+    # TODO: This should be renamed?
+    # TODO: These are tools that control the set of allowed functions in the next turn
+    child_based_tool_rules: List[Union[ChildToolRule, ConditionalToolRule, MaxCountPerStepToolRule]] = Field(
         default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
     )
     terminal_tool_rules: List[TerminalToolRule] = Field(
         default_factory=list, description="Terminal tool rules that end the agent loop if called."
     )
-    last_tool_name: Optional[str] = Field(None, description="The most recent tool used, updated with each tool call.")
+    tool_call_history: List[str] = Field(default_factory=list, description="History of tool calls, updated with each tool call.")
 
     def __init__(self, tool_rules: List[BaseToolRule], **kwargs):
         super().__init__(**kwargs)
@@ -38,45 +47,60 @@ class ToolRulesSolver(BaseModel):
                 self.init_tool_rules.append(rule)
             elif rule.type == ToolRuleType.constrain_child_tools:
                 assert isinstance(rule, ChildToolRule)
-                self.tool_rules.append(rule)
+                self.child_based_tool_rules.append(rule)
             elif rule.type == ToolRuleType.conditional:
                 assert isinstance(rule, ConditionalToolRule)
                 self.validate_conditional_tool(rule)
-                self.tool_rules.append(rule)
+                self.child_based_tool_rules.append(rule)
             elif rule.type == ToolRuleType.exit_loop:
                 assert isinstance(rule, TerminalToolRule)
                 self.terminal_tool_rules.append(rule)
             elif rule.type == ToolRuleType.continue_loop:
                 assert isinstance(rule, ContinueToolRule)
                 self.continue_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.max_count_per_step:
+                assert isinstance(rule, MaxCountPerStepToolRule)
+                self.child_based_tool_rules.append(rule)
 
     def update_tool_usage(self, tool_name: str):
-        """Update the internal state to track the last tool called."""
-        self.last_tool_name = tool_name
+        """Update the internal state to track tool call history."""
+        self.tool_call_history.append(tool_name)
 
-    def get_allowed_tool_names(self, error_on_empty: bool = False, last_function_response: Optional[str] = None) -> List[str]:
+    def clear_tool_history(self):
+        """Clear the history of tool calls."""
+        self.tool_call_history.clear()
+
+    def get_allowed_tool_names(
+        self, available_tools: Set[str], error_on_empty: bool = False, last_function_response: Optional[str] = None
+    ) -> List[str]:
         """Get a list of tool names allowed based on the last tool called."""
-        if self.last_tool_name is None:
-            # Use initial tool rules if no tool has been called yet
-            return [rule.tool_name for rule in self.init_tool_rules]
+        # TODO: This piece of code here is quite ugly and deserves a refactor
+        # TODO: There's some weird logic encoded here:
+        # TODO: -> This only takes into consideration Init, and a set of Child/Conditional/MaxSteps tool rules
+        # TODO: -> Init tool rules outputs are treated additively, Child/Conditional/MaxSteps are intersection based
+        # TODO: -> Tool rules should probably be refactored to take in a set of tool names?
+        # If no tool has been called yet, return InitToolRules additively
+        if not self.tool_call_history:
+            if self.init_tool_rules:
+                # If there are init tool rules, only return those defined in the init tool rules
+                return [rule.tool_name for rule in self.init_tool_rules]
+            else:
+                # Otherwise, return all the available tools
+                return list(available_tools)
         else:
-            # Find a matching ToolRule for the last tool used
-            current_rule = next((rule for rule in self.tool_rules if rule.tool_name == self.last_tool_name), None)
+            # Collect valid tools from all child-based rules
+            valid_tool_sets = [
+                rule.get_valid_tools(self.tool_call_history, available_tools, last_function_response)
+                for rule in self.child_based_tool_rules
+            ]
 
-            if current_rule is None:
-                if error_on_empty:
-                    raise ValueError(f"No tool rule found for {self.last_tool_name}")
-                return []
+            # Compute intersection of all valid tool sets
+            final_allowed_tools = set.intersection(*valid_tool_sets) if valid_tool_sets else available_tools
 
-            # If the current rule is a conditional tool rule, use the LLM response to
-            # determine which child tool to use
-            if isinstance(current_rule, ConditionalToolRule):
-                if not last_function_response:
-                    raise ValueError("Conditional tool rule requires an LLM response to determine which child tool to use")
-                next_tool = self.evaluate_conditional_tool(current_rule, last_function_response)
-                return [next_tool] if next_tool else []
+            if error_on_empty and not final_allowed_tools:
+                raise ValueError("No valid tools found based on tool rules.")
 
-            return current_rule.children if current_rule.children else []
+            return list(final_allowed_tools)
 
     def is_terminal_tool(self, tool_name: str) -> bool:
         """Check if the tool is defined as a terminal tool in the terminal tool rules."""
@@ -84,7 +108,7 @@ class ToolRulesSolver(BaseModel):
 
     def has_children_tools(self, tool_name):
         """Check if the tool has children tools"""
-        return any(rule.tool_name == tool_name for rule in self.tool_rules)
+        return any(rule.tool_name == tool_name for rule in self.child_based_tool_rules)
 
     def is_continue_tool(self, tool_name):
         """Check if the tool is defined as a continue tool in the tool rules."""
@@ -103,47 +127,3 @@ class ToolRulesSolver(BaseModel):
         if len(rule.child_output_mapping) == 0:
             raise ToolRuleValidationError("Conditional tool rule must have at least one child tool.")
         return True
-
-    def evaluate_conditional_tool(self, tool: ConditionalToolRule, last_function_response: str) -> str:
-        """
-        Parse function response to determine which child tool to use based on the mapping
-
-        Args:
-            tool (ConditionalToolRule): The conditional tool rule
-            last_function_response (str): The function response in JSON format
-
-        Returns:
-            str: The name of the child tool to use next
-        """
-        json_response = json.loads(last_function_response)
-        function_output = json_response["message"]
-
-        # Try to match the function output with a mapping key
-        for key in tool.child_output_mapping:
-
-            # Convert function output to match key type for comparison
-            if isinstance(key, bool):
-                typed_output = function_output.lower() == "true"
-            elif isinstance(key, int):
-                try:
-                    typed_output = int(function_output)
-                except (ValueError, TypeError):
-                    continue
-            elif isinstance(key, float):
-                try:
-                    typed_output = float(function_output)
-                except (ValueError, TypeError):
-                    continue
-            else:  # string
-                if function_output == "True" or function_output == "False":
-                    typed_output = function_output.lower()
-                elif function_output == "None":
-                    typed_output = None
-                else:
-                    typed_output = function_output
-
-            if typed_output == key:
-                return tool.child_output_mapping[key]
-
-        # If no match found, use default
-        return tool.default_child

letta/llm_api/anthropic.py

@@ -840,7 +840,7 @@ def anthropic_chat_completions_process_stream(
     # Create a dummy message for ID/datetime if needed
     dummy_message = _Message(
         role=_MessageRole.assistant,
-        text="",
+        content=[],
         agent_id="",
         model="",
         name=None,

letta/memory.py

@@ -37,7 +37,12 @@ def get_memory_functions(cls: Memory) -> Dict[str, Callable]:
 
 def _format_summary_history(message_history: List[Message]):
     # TODO use existing prompt formatters for this (eg ChatML)
-    return "\n".join([f"{m.role}: {m.content[0].text}" for m in message_history])
+    def get_message_text(content):
+        if content and len(content) == 1 and isinstance(content[0], TextContent):
+            return content[0].text
+        return ""
+
+    return "\n".join([f"{m.role}: {get_message_text(m.content)}" for m in message_history])
 
 
 def summarize_messages(

letta/orm/sqlalchemy_base.py

@@ -508,10 +508,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         raise NotImplementedError("Sqlalchemy models must declare a __pydantic_model__ property to be convertable.")
 
     def to_pydantic(self) -> "BaseModel":
-        """converts to the basic pydantic model counterpart"""
-        model = self.__pydantic_model__.model_validate(self)
-        if hasattr(self, "metadata_"):
-            model.metadata = self.metadata_
+        """Converts the SQLAlchemy model to its corresponding Pydantic model."""
+        model = self.__pydantic_model__.model_validate(self, from_attributes=True)
+
+        # Explicitly map metadata_ to metadata in Pydantic model
+        if hasattr(self, "metadata_") and hasattr(model, "metadata_"):
+            setattr(model, "metadata_", self.metadata_)  # Ensures correct assignment
+
         return model
 
     def pretty_print_columns(self) -> str:

letta/orm/tool.py

@@ -44,5 +44,6 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
     json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
     args_json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The JSON schema of the function arguments.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="A dictionary of additional metadata for the tool.")
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/schemas/enums.py

@@ -47,8 +47,4 @@ class ToolRuleType(str, Enum):
     continue_loop = "continue_loop"
     conditional = "conditional"
     constrain_child_tools = "constrain_child_tools"
-    require_parent_tools = "require_parent_tools"
-    # Deprecated
-    InitToolRule = "InitToolRule"
-    TerminalToolRule = "TerminalToolRule"
-    ToolRule = "ToolRule"
+    max_count_per_step = "max_count_per_step"

letta/schemas/message.py

@@ -748,6 +748,12 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
+        # Validate that parts is never empty before returning
+        if "parts" not in google_ai_message or not google_ai_message["parts"]:
+            # If parts is empty, add a default text part
+            google_ai_message["parts"] = [{"text": "empty message"}]
+            warnings.warn(f"Empty 'parts' detected in message with role '{self.role}'. Added default empty text part.")
+
         return google_ai_message
 
     def to_cohere_dict(

letta/schemas/source.py

@@ -50,7 +50,12 @@ class SourceCreate(BaseSource):
     # required
     name: str = Field(..., description="The name of the source.")
     # TODO: @matt, make this required after shub makes the FE changes
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")
+
+    embedding: Optional[str] = Field(None, description="The hande for the embedding config used by the source.")
+    embedding_chunk_size: Optional[int] = Field(None, description="The chunk size of the embedding.")
+
+    # TODO: remove (legacy config)
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="(Legacy) The embedding configuration used by the source.")
 
     # optional
     description: Optional[str] = Field(None, description="The description of the source.")

letta/schemas/tool.py

@@ -66,6 +66,7 @@ class Tool(BaseTool):
     # metadata fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    metadata_: Optional[Dict[str, Any]] = Field(default_factory=dict, description="A dictionary of additional metadata for the tool.")
 
     @model_validator(mode="after")
     def refresh_source_code_and_json_schema(self):
@@ -137,10 +138,6 @@ class ToolCreate(LettaBase):
 
     @classmethod
     def from_mcp(cls, mcp_server_name: str, mcp_tool: MCPTool) -> "ToolCreate":
-
-        # Get the MCP tool from the MCP server
-        # NVM
-
         # Pass the MCP tool to the schema generator
         json_schema = generate_tool_schema_for_mcp(mcp_tool=mcp_tool)
 

letta/schemas/tool_rule.py

@@ -1,4 +1,5 @@
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+import json
+from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Union
 
 from pydantic import Field
 
@@ -11,6 +12,9 @@ class BaseToolRule(LettaBase):
     tool_name: str = Field(..., description="The name of the tool. Must exist in the database for the user's organization.")
     type: ToolRuleType = Field(..., description="The type of the message.")
 
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> set[str]:
+        raise NotImplementedError
+
 
 class ChildToolRule(BaseToolRule):
     """
@@ -20,6 +24,10 @@ class ChildToolRule(BaseToolRule):
     type: Literal[ToolRuleType.constrain_child_tools] = ToolRuleType.constrain_child_tools
     children: List[str] = Field(..., description="The children tools that can be invoked.")
 
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
+        last_tool = tool_call_history[-1] if tool_call_history else None
+        return set(self.children) if last_tool == self.tool_name else available_tools
+
 
 class ConditionalToolRule(BaseToolRule):
     """
@@ -31,6 +39,50 @@ class ConditionalToolRule(BaseToolRule):
     child_output_mapping: Dict[Any, str] = Field(..., description="The output case to check for mapping")
     require_output_mapping: bool = Field(default=False, description="Whether to throw an error when output doesn't match any case")
 
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
+        """Determine valid tools based on function output mapping."""
+        if not tool_call_history or tool_call_history[-1] != self.tool_name:
+            return available_tools  # No constraints if this rule doesn't apply
+
+        if not last_function_response:
+            raise ValueError("Conditional tool rule requires an LLM response to determine which child tool to use")
+
+        try:
+            json_response = json.loads(last_function_response)
+            function_output = json_response.get("message", "")
+        except json.JSONDecodeError:
+            if self.require_output_mapping:
+                return set()  # Strict mode: Invalid response means no allowed tools
+            return {self.default_child} if self.default_child else available_tools
+
+        # Match function output to a mapped child tool
+        for key, tool in self.child_output_mapping.items():
+            if self._matches_key(function_output, key):
+                return {tool}
+
+        # If no match found, use default or allow all tools if no default is set
+        if self.require_output_mapping:
+            return set()  # Strict mode: No match means no valid tools
+
+        return {self.default_child} if self.default_child else available_tools
+
+    def _matches_key(self, function_output: str, key: Any) -> bool:
+        """Helper function to determine if function output matches a mapping key."""
+        if isinstance(key, bool):
+            return function_output.lower() == "true" if key else function_output.lower() == "false"
+        elif isinstance(key, int):
+            try:
+                return int(function_output) == key
+            except ValueError:
+                return False
+        elif isinstance(key, float):
+            try:
+                return float(function_output) == key
+            except ValueError:
+                return False
+        else:  # Assume string
+            return str(function_output) == str(key)
+
 
 class InitToolRule(BaseToolRule):
     """
@@ -56,7 +108,26 @@ class ContinueToolRule(BaseToolRule):
     type: Literal[ToolRuleType.continue_loop] = ToolRuleType.continue_loop
 
 
+class MaxCountPerStepToolRule(BaseToolRule):
+    """
+    Represents a tool rule configuration which constrains the total number of times this tool can be invoked in a single step.
+    """
+
+    type: Literal[ToolRuleType.max_count_per_step] = ToolRuleType.max_count_per_step
+    max_count_limit: int = Field(..., description="The max limit for the total number of times this tool can be invoked in a single step.")
+
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
+        """Restricts the tool if it has been called max_count_limit times in the current step."""
+        count = tool_call_history.count(self.tool_name)
+
+        # If the tool has been used max_count_limit times, it is no longer allowed
+        if count >= self.max_count_limit:
+            return available_tools - {self.tool_name}
+
+        return available_tools
+
+
 ToolRule = Annotated[
-    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule],
+    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule],
     Field(discriminator="type"),
 ]

letta/serialize_schemas/pydantic_agent_schema.py

@@ -15,7 +15,7 @@ class CoreMemoryBlockSchema(BaseModel):
     is_template: bool
     label: str
     limit: int
-    metadata_: Dict[str, Any] = Field(default_factory=dict)
+    metadata_: Optional[Dict] = None
     template_name: Optional[str]
     updated_at: str
     value: str
@@ -85,6 +85,7 @@ class ToolSchema(BaseModel):
     tags: List[str]
     tool_type: str
     updated_at: str
+    metadata_: Optional[Dict] = None
 
 
 class AgentSchema(BaseModel):
@@ -99,7 +100,7 @@ class AgentSchema(BaseModel):
     llm_config: LLMConfig
     message_buffer_autoclear: bool
     messages: List[MessageSchema]
-    metadata_: Dict
+    metadata_: Optional[Dict] = None
     multi_agent_group: Optional[Any]
     name: str
     system: str

letta/server/rest_api/app.py

@@ -256,15 +256,15 @@ def create_application() -> "FastAPI":
     )
 
     # Set up OpenTelemetry tracing
-    endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-    if endpoint:
-        print(f"▶ Using OTLP tracing with endpoint: {endpoint}")
+    otlp_endpoint = settings.otel_exporter_otlp_endpoint
+    if otlp_endpoint and not settings.disable_tracing:
+        print(f"▶ Using OTLP tracing with endpoint: {otlp_endpoint}")
         env_name_suffix = os.getenv("ENV_NAME")
         service_name = f"letta-server-{env_name_suffix.lower()}" if env_name_suffix else "letta-server"
         from letta.tracing import setup_tracing
 
         setup_tracing(
-            endpoint=endpoint,
+            endpoint=otlp_endpoint,
             app=app,
             service_name=service_name,
         )
@@ -326,7 +326,7 @@ def start_server(
         print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
         print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
         uvicorn.run(
-            app,
+            "letta.server.rest_api.app:app",
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,
@@ -345,7 +345,7 @@ def start_server(
             print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
 
         uvicorn.run(
-            app,
+            "letta.server.rest_api.app:app",
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,

letta/server/rest_api/routers/v1/sources.py

@@ -76,8 +76,20 @@ def create_source(
     Create a new data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    source = Source(**source_create.model_dump())
-
+    if not source_create.embedding_config:
+        if not source_create.embedding:
+            # TODO: modify error type
+            raise ValueError("Must specify either embedding or embedding_config in request")
+        source_create.embedding_config = server.get_embedding_config_from_handle(
+            handle=source_create.embedding,
+            embedding_chunk_size=source_create.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
+        )
+    source = Source(
+        name=source_create.name,
+        embedding_config=source_create.embedding_config,
+        description=source_create.description,
+        metadata=source_create.metadata,
+    )
     return server.source_manager.create_source(source=source, actor=actor)
 
 
@@ -91,6 +103,7 @@ def modify_source(
     """
     Update the name or documentation of an existing data source.
     """
+    # TODO: allow updating the handle/embedding config
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     if not server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
         raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")

letta/server/rest_api/routers/v1/tools.py

@@ -398,7 +398,7 @@ def add_mcp_tool(
         )
 
     tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
-    return server.tool_manager.create_or_update_mcp_tool(tool_create=tool_create, actor=actor)
+    return server.tool_manager.create_or_update_mcp_tool(tool_create=tool_create, mcp_server_name=mcp_server_name, actor=actor)
 
 
 @router.put("/mcp/servers", response_model=List[Union[StdioServerConfig, SSEServerConfig]], operation_id="add_mcp_server")

letta/server/server.py

@@ -332,14 +332,14 @@ class SyncServer(Server):
 
         for server_name, server_config in mcp_server_configs.items():
             if server_config.type == MCPServerType.SSE:
-                self.mcp_clients[server_name] = SSEMCPClient()
+                self.mcp_clients[server_name] = SSEMCPClient(server_config)
             elif server_config.type == MCPServerType.STDIO:
-                self.mcp_clients[server_name] = StdioMCPClient()
+                self.mcp_clients[server_name] = StdioMCPClient(server_config)
             else:
                 raise ValueError(f"Invalid MCP server config: {server_config}")
 
             try:
-                self.mcp_clients[server_name].connect_to_server(server_config)
+                self.mcp_clients[server_name].connect_to_server()
             except Exception as e:
                 logger.error(e)
                 self.mcp_clients.pop(server_name)
@@ -723,10 +723,17 @@ class SyncServer(Server):
                 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)
+                    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)
+                    message_content = system.package_system_message(system_message=message_content)
                 else:
                     raise ValueError(f"Invalid message role: {message.role}")
 
@@ -735,7 +742,7 @@ class SyncServer(Server):
                     Message(
                         agent_id=agent_id,
                         role=message.role,
-                        content=[TextContent(text=message.content)] if message.content else [],
+                        content=[TextContent(text=message_content)] if message_content else [],
                         name=message.name,
                         # assigned later?
                         model=None,
@@ -1266,6 +1273,11 @@ class SyncServer(Server):
     # TODO support both command + SSE servers (via config)
     def get_mcp_servers(self) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
         """List the MCP servers in the config (doesn't test that they are actually working)"""
+
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         mcp_server_list = {}
 
         # Attempt to read from ~/.letta/mcp_config.json
@@ -1326,13 +1338,18 @@ class SyncServer(Server):
 
     def add_mcp_server_to_config(
         self, server_config: Union[SSEServerConfig, StdioServerConfig], allow_upsert: bool = True
-    ) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
+    ) -> List[Union[SSEServerConfig, StdioServerConfig]]:
         """Add a new server config to the MCP config file"""
 
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         # If the config file doesn't exist, throw an error.
         mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
         if not os.path.exists(mcp_config_path):
-            raise FileNotFoundError(f"MCP config file not found: {mcp_config_path}")
+            # Create the file if it doesn't exist
+            logger.debug(f"MCP config file not found, creating new file at: {mcp_config_path}")
 
         # If the file does exist, attempt to parse it get calling get_mcp_servers
         try:
@@ -1348,13 +1365,13 @@ class SyncServer(Server):
 
         # Attempt to initialize the connection to the server
         if server_config.type == MCPServerType.SSE:
-            new_mcp_client = SSEMCPClient()
+            new_mcp_client = SSEMCPClient(server_config)
         elif server_config.type == MCPServerType.STDIO:
-            new_mcp_client = StdioMCPClient()
+            new_mcp_client = StdioMCPClient(server_config)
         else:
             raise ValueError(f"Invalid MCP server config: {server_config}")
         try:
-            new_mcp_client.connect_to_server(server_config)
+            new_mcp_client.connect_to_server()
         except:
             logger.exception(f"Failed to connect to MCP server: {server_config.server_name}")
             raise RuntimeError(f"Failed to connect to MCP server: {server_config.server_name}")
@@ -1384,9 +1401,14 @@ class SyncServer(Server):
     def delete_mcp_server_from_config(self, server_name: str) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
         """Delete a server config from the MCP config file"""
 
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         # If the config file doesn't exist, throw an error.
         mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
         if not os.path.exists(mcp_config_path):
+            # If the file doesn't exist, raise an error
             raise FileNotFoundError(f"MCP config file not found: {mcp_config_path}")
 
         # If the file does exist, attempt to parse it get calling get_mcp_servers

letta/services/tool_manager.py

@@ -2,7 +2,7 @@ import importlib
 import warnings
 from typing import List, Optional
 
-from letta.constants import BASE_FUNCTION_RETURN_CHAR_LIMIT, BASE_MEMORY_TOOLS, BASE_TOOLS, MULTI_AGENT_TOOLS
+from letta.constants import BASE_FUNCTION_RETURN_CHAR_LIMIT, BASE_MEMORY_TOOLS, BASE_TOOLS, MCP_TOOL_TAG_NAME_PREFIX, MULTI_AGENT_TOOLS
 from letta.functions.functions import derive_openai_json_schema, load_function_set
 from letta.log import get_logger
 from letta.orm.enums import ToolType
@@ -57,9 +57,13 @@ class ToolManager:
         return tool
 
     @enforce_types
-    def create_or_update_mcp_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+    def create_or_update_mcp_tool(self, tool_create: ToolCreate, mcp_server_name: str, actor: PydanticUser) -> PydanticTool:
+        metadata = {MCP_TOOL_TAG_NAME_PREFIX: {"server_name": mcp_server_name}}
         return self.create_or_update_tool(
-            PydanticTool(tool_type=ToolType.EXTERNAL_MCP, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
+            PydanticTool(
+                tool_type=ToolType.EXTERNAL_MCP, name=tool_create.json_schema["name"], metadata_=metadata, **tool_create.model_dump()
+            ),
+            actor,
         )
 
     @enforce_types

letta/settings.py

@@ -18,6 +18,12 @@ class ToolSettings(BaseSettings):
     # Local Sandbox configurations
     local_sandbox_dir: Optional[str] = None
 
+    # MCP settings
+    mcp_connect_to_server_timeout: float = 15.0
+    mcp_list_tools_timeout: float = 10.0
+    mcp_execute_tool_timeout: float = 60.0
+    mcp_read_from_config: bool = True  # if False, will throw if attempting to read/write from file
+
 
 class SummarizerSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="letta_summarizer_", extra="ignore")
@@ -174,6 +180,7 @@ class Settings(BaseSettings):
     # telemetry logging
     verbose_telemetry_logging: bool = False
     otel_exporter_otlp_endpoint: str = "http://localhost:4317"
+    disable_tracing: bool = False
 
     # uvicorn settings
     uvicorn_workers: int = 1

letta/supervisor_multi_agent.py

@@ -3,16 +3,18 @@ from typing import List, Optional
 from letta.agent import Agent, AgentState
 from letta.constants import DEFAULT_MESSAGE_TOOL
 from letta.functions.function_sets.multi_agent import send_message_to_all_agents_in_group
+from letta.functions.functions import parse_source_code
+from letta.functions.schema_generator import generate_schema
 from letta.interface import AgentInterface
 from letta.orm import User
 from letta.orm.enums import ToolType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
+from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.tool_manager import ToolManager
-from tests.helpers.utils import create_tool_from_func
 
 
 class SupervisorMultiAgent(Agent):
@@ -47,7 +49,14 @@ class SupervisorMultiAgent(Agent):
 
         # add multi agent tool
         if self.tool_manager.get_tool_by_name(tool_name="send_message_to_all_agents_in_group", actor=self.user) is None:
-            multi_agent_tool = create_tool_from_func(send_message_to_all_agents_in_group)
+            multi_agent_tool = Tool(
+                name=send_message_to_all_agents_in_group.__name__,
+                description="",
+                source_type="python",
+                tags=[],
+                source_code=parse_source_code(send_message_to_all_agents_in_group),
+                json_schema=generate_schema(send_message_to_all_agents_in_group, None),
+            )
             multi_agent_tool.tool_type = ToolType.LETTA_MULTI_AGENT_CORE
             multi_agent_tool = self.tool_manager.create_or_update_tool(
                 pydantic_tool=multi_agent_tool,

letta/tracing.py

@@ -90,8 +90,8 @@ async def trace_error_handler(_request: Request, exc: Exception) -> JSONResponse
     # Add error details to current span
     span = trace.get_current_span()
     if span:
-        span.add_event(
-            name="exception",
+        span.record_exception(
+            exc,
             attributes={
                 "exception.message": error_msg,
                 "exception.type": type(exc).__name__,
@@ -112,6 +112,16 @@ def setup_tracing(
     global _is_tracing_initialized
 
     provider = TracerProvider(resource=Resource.create({"service.name": service_name}))
+    import uuid
+
+    provider = TracerProvider(
+        resource=Resource.create(
+            {
+                "service.name": service_name,
+                "device.id": uuid.getnode(),  # MAC address as unique device identifier
+            }
+        )
+    )
     if endpoint:
         provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint)))
         _is_tracing_initialized = True

{letta_nightly-0.6.41.dev20250317104157.dist-info → letta_nightly-0.6.43.dev20250318012126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.41.dev20250317104157
+Version: 0.6.43.dev20250318012126
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -31,7 +31,7 @@ Requires-Dist: brotli (>=1.1.0,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
-Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
+Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0)
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)

{letta_nightly-0.6.41.dev20250317104157.dist-info → letta_nightly-0.6.43.dev20250318012126.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=JZZg-67nC15yHnBqHm2_pXiqP-XF7i9RHClzkczUwtI,918
+letta/__init__.py,sha256=d3F-DwijWs3SOdYADCZaqCu4IbjBND6Ba0ZTRL-G3ro,918
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=xBXIgaeiGXDBpgNKX0-2w10iRBBvcLgBK0W85jTiSX8,68141
+letta/agent.py,sha256=hPFLDf68QqSVIP22dr40h21Jewif0Aq8IbAjrRHM0MI,68511
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/base_agent.py,sha256=8IMB7UK4ft-Wi-ZYjX7akqQUhk_cSswRgepqeZyvCMs,1550
 letta/agents/ephemeral_agent.py,sha256=DBMXT50UQoqjkvl_Piwle3Fy7iXopy15oMWwnWzbpvo,2751
@@ -19,7 +19,7 @@ letta/constants.py,sha256=_QI06HD6yLmGFrTqexLkUnUWSsKUiBlM1QtbiLGEq4k,7773
 letta/data_sources/connectors.py,sha256=R2AssXpqS7wN6VI8AfxvqaZs5S1ZACc4E_FewmR9iZI,7022
 letta/data_sources/connectors_helper.py,sha256=oQpVlc-BjSz9sTZ7sp4PsJSXJbBKpZPi3Dam03CURTQ,3376
 letta/dynamic_multi_agent.py,sha256=syJ-uODfZR_OHd4Acx19yMvjSJ2jwjyX0SOPaeLsZ38,12056
-letta/embeddings.py,sha256=zqlfbN3aCgSOlNd9M2NW9zrwx4WwQzketb8oa5BzzE8,10831
+letta/embeddings.py,sha256=0XHDkca0cXvqSEU06fWfpSfOODU_3HcqDaSh6kuP6EM,11115
 letta/errors.py,sha256=6fQXg2unP-2fo3R7db0ayKKWlD2XMusOPNi9TgJplCg,5558
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/ast_parsers.py,sha256=CQI0rUoIXcLKAev_GYrXcldRIGN5ZQtk5u4FLoHe5sE,5728
@@ -30,18 +30,18 @@ letta/functions/functions.py,sha256=NyWLh7a-f4mXti5vM1oWDwXzfA58VmVVqL03O9vosKY,
 letta/functions/helpers.py,sha256=0I-ezZeM3slhAifpdlR5k2Rn6GxExD6xACCKuoYmE8M,29119
 letta/functions/interface.py,sha256=s_PPp5WDvGH_y9KUpMlORkdC141ITczFk3wsevrrUD8,2866
 letta/functions/mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/functions/mcp_client/base_client.py,sha256=uHp4XuXFy3avCkc3XYr1IxEPTHZWADqrDk-kR-oFyLY,2144
-letta/functions/mcp_client/sse_client.py,sha256=VElaM87sEMTvam4t3IJgWGhyqs5BL4YVErqVPv2hQug,961
-letta/functions/mcp_client/stdio_client.py,sha256=qy9vHB99oI4pCAQ4KmQUKY0bTboaQI4pnPm9DPQfPvY,4210
+letta/functions/mcp_client/base_client.py,sha256=n2j1wEDopF8BkivkqrZDWrq3I2gChVfkQ0MgH4Iyg1I,3507
+letta/functions/mcp_client/sse_client.py,sha256=XOLnWIcrjBEkZ-IksgnHKSdVds3pC2E8OPkIhCNxloo,1470
+letta/functions/mcp_client/stdio_client.py,sha256=2oouLGphu4S15OrYj97n9_ZYZo-GMRWNLWwaw-U4TNs,4562
 letta/functions/mcp_client/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
 letta/functions/schema_generator.py,sha256=4hiDQpHemyfKWME-5X6xJuSiv7g9V_BgAPFegohHBIM,22327
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/composio_helpers.py,sha256=6CWV483vE3N-keQlblexxBiQHxorMAgQuvbok4adGO4,949
-letta/helpers/converters.py,sha256=3qHoPDPa7ycPeeE6eLYZ8mad1mA6oGPgY95lDyhb3_A,8971
+letta/helpers/converters.py,sha256=ndAm9p7cfA1YuoLdZOV7rTFADz2iyeUt_OZtaI5GFO0,9037
 letta/helpers/datetime_helpers.py,sha256=7U5ZJkE0cLki4sG8ukIHZSAoFfQpLWQu2kFekETy6Zg,2633
 letta/helpers/json_helpers.py,sha256=PWZ5HhSqGXO4e563dM_8M72q7ScirjXQ4Rv1ckohaV8,396
 letta/helpers/tool_execution_helper.py,sha256=bskCscuz2nqoUboFcYA7sQGeikdEyqiYnNpO4gLQTdc,7469
-letta/helpers/tool_rule_solver.py,sha256=z-2Zq_qWykgWanFZYxtxUee4FkMnxqvntXe2tomoH68,6774
+letta/helpers/tool_rule_solver.py,sha256=Vv_wXLXc5CcSAn5DJDTZmnhC58HgcCA2RusYNYU5quA,6035
 letta/humans/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/humans/examples/basic.txt,sha256=Lcp8YESTWvOJgO4Yf_yyQmgo5bKakeB1nIVrwEGG6PA,17
 letta/humans/examples/cs_phd.txt,sha256=9C9ZAV_VuG7GB31ksy3-_NAyk8rjE6YtVOkhp08k1xw,297
@@ -50,7 +50,7 @@ letta/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 letta/interfaces/openai_chat_completions_streaming_interface.py,sha256=SfqVp7V7AbBqv8D_IwyqrcztNiI0nKhjAvqtZQE_jfM,4729
 letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/llm_api/anthropic.py,sha256=pDj9W_Myz4fe05eoMiApO45G8jqzVoO9QyfFpCs-uV0,38360
+letta/llm_api/anthropic.py,sha256=XHmy2MJvV6y-Rc-GOv2M8xdaB5jmEcp7SMKI2Wc4izw,38363
 letta/llm_api/aws_bedrock.py,sha256=J_oCM810-m2T-tgo3iRwSM0BuykBN5AK3SbkyiOaGbc,3835
 letta/llm_api/azure_openai.py,sha256=GP50e3WyoU2O_vb_b06GYTA1S157I0G21lF9-qv9nsA,6459
 letta/llm_api/azure_openai_constants.py,sha256=ZaR2IasJThijG0uhLKJThrixdAxLPD2IojfeaJ-KQMQ,294
@@ -106,7 +106,7 @@ letta/local_llm/webui/legacy_settings.py,sha256=BLmd3TSx5StnY3ibjwaxYATPt_Lvq-o1
 letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ftVPh8,552
 letta/log.py,sha256=FbFwU9KEX7k0FBYhPl7fJ6uQ3NO3-ZbsnM2OpcTFXjo,2217
 letta/main.py,sha256=_agyaYPJq70OL0goNwO34zENL2KupnTgqlg-HVcNaTY,15379
-letta/memory.py,sha256=JjKripPdzsCxXCPYBmFP_yRVN_PSqEQW5s8EKK-Mt9M,3411
+letta/memory.py,sha256=dGzMdYYG1Mhan9POLcmyI6fVL7Xs8TEozWfAo4v1QQo,3592
 letta/offline_memory_agent.py,sha256=P_rm6GmKAH6lg7-njuv7dK29f7v5-tAQy-rMOwcPfwk,7499
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=GSzeCTwLpLD2fH4X8wVqzwdmoTjKK2I4PnriBY453lc,13505
@@ -136,10 +136,10 @@ letta/orm/provider.py,sha256=-qA9tvKTZgaM4D7CoDZZiA7zTgjaaWDV4jZvifQv_MM,805
 letta/orm/sandbox_config.py,sha256=DyOy_1_zCMlp13elCqPcuuA6OwUove6mrjhcpROTg50,4150
 letta/orm/source.py,sha256=z89VZUHV9K8Ew9JCYoZqUeRb1WEUKmrn0MMFkppaphE,2117
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
-letta/orm/sqlalchemy_base.py,sha256=IaiVDy7q5mZsP2x2ME0IFyI6KYMwMiKb5oHODqfiDNs,22491
+letta/orm/sqlalchemy_base.py,sha256=3jb795D-hK7o4paLjniHkPP9EnUtLG0bfHrc2OpD5QI,22672
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
 letta/orm/step.py,sha256=fjm7fLtYLCtFM6Mj6e2boP6P7dHSFG24Nem85VfVqHg,3216
-letta/orm/tool.py,sha256=x58lmVG5IhXTVt82CnoN-ExuObnQCbeSMx_yOhUMmA4,2515
+letta/orm/tool.py,sha256=ft3BDA7Pt-zsXLyPvS_Z_Ibis6H6vY20F7Li7p6nPu8,2652
 letta/orm/tools_agents.py,sha256=r6t-V21w2_mG8n38zuUb5jOi_3hRxsjgezsLA4sg0m4,626
 letta/orm/user.py,sha256=rK5N5ViDxmesZMqVVHB7FcQNpcSoM-hB42MyI6q3MnI,1004
 letta/personas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -175,7 +175,7 @@ letta/schemas/agent.py,sha256=YjjzBIA4txW5LzQjVoDfXHgNZQh8HCYZ7tOyYVlbU0s,14276
 letta/schemas/block.py,sha256=rMWflyj982qW86dQK-9saXBHKaLCu3aUG2gQTckG3Ik,4984
 letta/schemas/embedding_config.py,sha256=ufboqW9ctSBJdhwzJRbrGtTzOTwSKfT0LY0mowpr6fs,3398
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
-letta/schemas/enums.py,sha256=zBNS0iIDtAS9mrDafin4mY33LLPUxq_SoPx6z5BiM_g,1156
+letta/schemas/enums.py,sha256=0tOunJGgrTlORWkl3HrFkFjBT-4KgA2Y9QpLceoY2yY,1033
 letta/schemas/environment_variables.py,sha256=VRtzOjdeQdHcSHXisk7oJUQlheruxhSWNS0xqlfGzbs,2429
 letta/schemas/file.py,sha256=ChN2CWzLI2TT9WLItcfElEH0E8b7kzPylF2OQBr6Beg,1550
 letta/schemas/group.py,sha256=fniDxIkgrYxo8yR1br-ZqhjjhOIaFqG-JMYHWo2J81Y,2141
@@ -190,7 +190,7 @@ letta/schemas/letta_response.py,sha256=pq-SxXQy5yZo1-DiAwV2mMURlUvz1Uu7HHR_tB1hM
 letta/schemas/llm_config.py,sha256=bqq4LGE9layPcnnkzd_8d2SB8o1x8XdDzfd2ZkYQwcY,5611
 letta/schemas/llm_config_overrides.py,sha256=-oRglCTcajF6UAK3RAa0FLWVuKODPI1v403fDIWMAtA,1815
 letta/schemas/memory.py,sha256=GOYDfPKzbWftUWO9Hv4KW7xAi1EIQmC8zpP7qvEkVHw,10245
-letta/schemas/message.py,sha256=1V9_1OZxVkkKeBx9Y9WcrnHF0ggc2zeV3K-Wix8mYBA,39339
+letta/schemas/message.py,sha256=2bpl6VAqIaz6Rzqcq_NcPjbmlq7zvZx7sYFht1hs1_c,39727
 letta/schemas/openai/chat_completion_request.py,sha256=3tALmbBV2pv1CcqzNLBxxIPOQ8Z85woucT7FN0fuDic,3402
 letta/schemas/openai/chat_completion_response.py,sha256=koEb_NTiz5YsAAX81Z0cSqSFX4a6MdD2lhoXtxF_rw4,4100
 letta/schemas/openai/chat_completions.py,sha256=l0e9sT9boTD5VBU5YtJ0s7qUtCfFGB2K-gQLeEZ2LHU,3599
@@ -201,10 +201,10 @@ letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
 letta/schemas/providers.py,sha256=2Ijzjj1gPETiFyl8yb4ZbwaTljw5WSCdGayAgCsBeYE,43665
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=SZCo3FSMz-DIBMKGu0atT4tsVFXGsqMFPaJnjrxpkX4,5993
-letta/schemas/source.py,sha256=-BQVolcXA2ziCu2ztR6cbTdGUc8G7vGJy7rvpdf1hpg,2880
+letta/schemas/source.py,sha256=IuenIFs7B8uOuYJIHXqR1E28wVSa-pUX6NkLZH7cukg,3141
 letta/schemas/step.py,sha256=WkcVnruUUOWLKwiWPn2Gfal4EQZPNLqlsd9859xhgsw,2224
-letta/schemas/tool.py,sha256=PXWxEqzM-kADijlsJzu0ZYtWLnjpq4ZUNX4NzesIWNQ,12291
-letta/schemas/tool_rule.py,sha256=2YQZba4fXS3u4j8pIk7BDujfq8rnxSVMwJSyaVgApH4,2149
+letta/schemas/tool.py,sha256=3hm9SJhHG0d6-ychZXBDsKcI83_6So-qKxTLaFRQqko,12363
+letta/schemas/tool_rule.py,sha256=tZ-BoyFJcFLMOd8KIng8pw3yCtdV8KGh4Vz730ZA-WQ,5674
 letta/schemas/usage.py,sha256=8oYRH-JX0PfjIu2zkT5Uu3UWQ7Unnz_uHiO8hRGI4m0,912
 letta/schemas/user.py,sha256=V32Tgl6oqB3KznkxUz12y7agkQicjzW7VocSpj78i6Q,1526
 letta/serialize_schemas/__init__.py,sha256=cosMjvWz7cubC1azbUofzYrcDBTuSgjJImUdsrSs3p0,77
@@ -216,13 +216,13 @@ letta/serialize_schemas/marshmallow_custom_fields.py,sha256=_rXV4eGY4wKqzZQPyk3o
 letta/serialize_schemas/marshmallow_message.py,sha256=vkBlIFONzsiREXo507sWl1mjVjCLV97RtB7jyE0N_fw,1336
 letta/serialize_schemas/marshmallow_tag.py,sha256=ssNGdD-z9UafhoTTOcvWRXju__NSx1bPijae_vljMr4,682
 letta/serialize_schemas/marshmallow_tool.py,sha256=98dzHzKcH_HE5n_gCkU683iHvg1M9IGmRZ2BWnh__j4,404
-letta/serialize_schemas/pydantic_agent_schema.py,sha256=4FfF405nyH3lpTpU6r1vkZmP5916FhuEcgaEqpiAMko,2633
+letta/serialize_schemas/pydantic_agent_schema.py,sha256=hsf0l1RiAbFrGUYNsRg21L4S7QUD6z_-Wft5QigPiOM,2664
 letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=cA1MHpMCTTC1MX7VWppJ-cKq1XW93Vws_vTV0-bKmTE,3642
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=gP558sE9dY4914GYVPuypPwYiGHaVtfeWSsOUZBq67c,13618
+letta/server/rest_api/app.py,sha256=Y4QZZWh0mI4d7o7ZZh8G4A9ib_CBBDz9DtaLrH-9fXU,13723
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
@@ -244,15 +244,15 @@ letta/server/rest_api/routers/v1/organizations.py,sha256=8n-kA9LHtKImdY2xL-v7m6n
 letta/server/rest_api/routers/v1/providers.py,sha256=qyZsNTXgLVsoLZoCVY4qaqiG34zCEVmRUP2Cn6maK_4,2949
 letta/server/rest_api/routers/v1/runs.py,sha256=-2_YA2nuxcLqiPjG9CPHeZbyrtlNQZnAsaNohGn5fMg,8278
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=9hqnnMwJ3wCwO-Bezu3Xl8i3TDSIuInw3gSeHaKUXfE,8526
-letta/server/rest_api/routers/v1/sources.py,sha256=rpQhaRHyzGUK43LX623L8BBLqL85HJ6fUYPMvI4k3kA,8434
+letta/server/rest_api/routers/v1/sources.py,sha256=-3JB2ohr4hqkB7Zw0frTG1PN2KplU1SRr2mLX6KXJ44,9104
 letta/server/rest_api/routers/v1/steps.py,sha256=DVVwaxLNbNAgWpr2oQkrNjdS-wi0bP8kVJZUO-hiaf8,3275
 letta/server/rest_api/routers/v1/tags.py,sha256=coydgvL6-9cuG2Hy5Ea7QY3inhTHlsf69w0tcZenBus,880
-letta/server/rest_api/routers/v1/tools.py,sha256=pWIlYUksq9QNFSmknB_DdSB5zs77zaHoj-Ha-WxYkO8,17211
+letta/server/rest_api/routers/v1/tools.py,sha256=wDj8L_-qd4FGiLa2zJMKIsRPxpWjWP0x2clkU0SBvTQ,17244
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
 letta/server/rest_api/routers/v1/voice.py,sha256=7J0L-Nkz65m0PXcpQI2ATMIZzumDDSUzgtIus7d-tv8,2461
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=aF0u__Q33-aPWAiHi9JA0jKAjqnwbVKzJdD5NgFpnOU,13828
-letta/server/server.py,sha256=Ml4-MklB28x3iAONfp3m2oSbrhVctAvvxUWApeWIWrk,75884
+letta/server/server.py,sha256=YT0Bxl6rkoXilCkVnFFGkT9bvK1cAG_RVDho3UeJ8eg,76962
 letta/server/startup.sh,sha256=2S_MuvYYY5YZQOYBL-7mq2CC-A7Hhwyd9be2QqmNqzA,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -285,17 +285,17 @@ letta/services/summarizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7ozi7A,208
 letta/services/summarizer/summarizer.py,sha256=qPcR7VsHsgUsUtxmKx_73l3XdDhFvDzZ8VeIs4w3NBc,4757
 letta/services/tool_execution_sandbox.py,sha256=6AB3rFS34PzoyE9dxtUmuaUUWvKrwdE083NuBRa1eC0,22969
-letta/services/tool_manager.py,sha256=rXOdB2quTWE9EGjkg9Q4EY6-hAwX2R9gGBCXFs8hR4w,9862
+letta/services/tool_manager.py,sha256=CAXkbw8cv6LZ8Do9lloWw0biKH0lBf-qtsdq0yedhbQ,10053
 letta/services/user_manager.py,sha256=ScHbdJK9kNF8QXjsd3ZWGEL87n_Uyp3YwfKetOJmpHs,4304
-letta/settings.py,sha256=W3gFFywjk6CKbWTSlj0zXGyzl8CJUrQJgMLvq2sKEWA,7074
+letta/settings.py,sha256=dRXIVQwgq5V1fH7H5KZN1guuBlCNgvDapZ88r1IMC7s,7360
 letta/streaming_interface.py,sha256=1vuAckIxo1p1UsXtDzE8LTUve5RoTZRdXUe-WBIYDWU,15818
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
-letta/supervisor_multi_agent.py,sha256=dw6XPAxZcyjAXEVYkMIxJFhZdR2m2_rq-fYev5hZE50,3936
+letta/supervisor_multi_agent.py,sha256=jMy0J-a1_u5ZCulweXwJ98SgF6Hnvwxh1L3_wavnTi4,4330
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
-letta/tracing.py,sha256=e1dNfdMI__38E-_xMxPrxyM5mSGil8Od1tSbf_UNWaY,8004
+letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=AdHrQ2OQ3V4XhJ1LtYwbLUO71j2IJY37cIUxXPgaaRY,32125
-letta_nightly-0.6.41.dev20250317104157.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.41.dev20250317104157.dist-info/METADATA,sha256=Tg27LnMLvS_yubSnumqbGU_5pXTCdM0V-BzpEMywOKs,22886
-letta_nightly-0.6.41.dev20250317104157.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.41.dev20250317104157.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.41.dev20250317104157.dist-info/RECORD,,
+letta_nightly-0.6.43.dev20250318012126.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.43.dev20250318012126.dist-info/METADATA,sha256=vVaOSTkQsHF743XpzwI9bL1K4ulPjiMU1Z5cFUUtzPQ,22847
+letta_nightly-0.6.43.dev20250318012126.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.43.dev20250318012126.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.43.dev20250318012126.dist-info/RECORD,,