letta-nightly 0.11.2.dev20250811104433__py3-none-any.whl → 0.11.3.dev20250812002120__py3-none-any.whl

letta/schemas/llm_config.py

@@ -94,6 +94,9 @@ class LLMConfig(BaseModel):
         """
         model = values.get("model")
 
+        if model is None:
+            return values
+
         # Define models where we want put_inner_thoughts_in_kwargs to be False
         avoid_put_inner_thoughts_in_kwargs = ["gpt-4"]
 
@@ -107,25 +110,13 @@ class LLMConfig(BaseModel):
         if is_openai_reasoning_model(model):
             values["put_inner_thoughts_in_kwargs"] = False
 
-        if values.get("enable_reasoner") and values.get("model_endpoint_type") == "anthropic":
+        if values.get("model_endpoint_type") == "anthropic" and (
+            model.startswith("claude-3-7-sonnet") or model.startswith("claude-sonnet-4") or model.startswith("claude-opus-4")
+        ):
             values["put_inner_thoughts_in_kwargs"] = False
 
         return values
 
-    @model_validator(mode="after")
-    def issue_warning_for_reasoning_constraints(self) -> "LLMConfig":
-        if self.enable_reasoner:
-            if self.max_reasoning_tokens is None:
-                logger.warning("max_reasoning_tokens must be set when enable_reasoner is True")
-            if self.max_tokens is not None and self.max_reasoning_tokens >= self.max_tokens:
-                logger.warning("max_tokens must be greater than max_reasoning_tokens (thinking budget)")
-            if self.put_inner_thoughts_in_kwargs:
-                logger.debug("Extended thinking is not compatible with put_inner_thoughts_in_kwargs")
-        elif self.max_reasoning_tokens and not self.enable_reasoner:
-            logger.warning("model will not use reasoning unless enable_reasoner is set to True")
-
-        return self
-
     @classmethod
     def default_config(cls, model_name: str):
         """
@@ -185,31 +176,50 @@ class LLMConfig(BaseModel):
             + (f" [ip={self.model_endpoint}]" if self.model_endpoint else "")
         )
 
+    @classmethod
+    def is_openai_reasoning_model(cls, config: "LLMConfig") -> bool:
+        return config.model_endpoint_type == "openai" and (
+            config.model.startswith("o1") or config.model.startswith("o3") or config.model.startswith("o4")
+        )
+
+    @classmethod
+    def is_anthropic_reasoning_model(cls, config: "LLMConfig") -> bool:
+        return config.model_endpoint_type == "anthropic" and (
+            config.model.startswith("claude-opus-4")
+            or config.model.startswith("claude-sonnet-4")
+            or config.model.startswith("claude-3-7-sonnet")
+        )
+
+    @classmethod
+    def is_google_vertex_reasoning_model(cls, config: "LLMConfig") -> bool:
+        return config.model_endpoint_type == "google_vertex" and (
+            config.model.startswith("gemini-2.5-flash") or config.model.startswith("gemini-2.5-pro")
+        )
+
     @classmethod
     def apply_reasoning_setting_to_config(cls, config: "LLMConfig", reasoning: bool):
         if not reasoning:
+            if cls.is_openai_reasoning_model(config) or config.model.startswith("gemini-2.5-pro"):
+                raise ValueError("Reasoning cannot be disabled for OpenAI o1/o3 models")
             config.put_inner_thoughts_in_kwargs = False
             config.enable_reasoner = False
 
         else:
             config.enable_reasoner = True
-            if (
-                config.model_endpoint_type == "anthropic"
-                and ("claude-opus-4" in config.model or "claude-sonnet-4" in config.model or "claude-3-7-sonnet" in config.model)
-            ) or (
-                config.model_endpoint_type == "google_vertex" and ("gemini-2.5-flash" in config.model or "gemini-2.0-pro" in config.model)
-            ):
+            if cls.is_anthropic_reasoning_model(config):
                 config.put_inner_thoughts_in_kwargs = False
                 if config.max_reasoning_tokens == 0:
                     config.max_reasoning_tokens = 1024
-            elif config.model_endpoint_type == "openai" and (
-                config.model.startswith("o1") or config.model.startswith("o3") or config.model.startswith("o4")
-            ):
+            elif cls.is_google_vertex_reasoning_model(config):
+                # Handle as non-reasoner until we support summary
+                config.put_inner_thoughts_in_kwargs = True
+                if config.max_reasoning_tokens == 0:
+                    config.max_reasoning_tokens = 1024
+            elif cls.is_openai_reasoning_model(config):
                 config.put_inner_thoughts_in_kwargs = False
                 if config.reasoning_effort is None:
                     config.reasoning_effort = "medium"
             else:
                 config.put_inner_thoughts_in_kwargs = True
-                config.enable_reasoner = False
 
         return config

letta/schemas/response_format.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Annotated, Any, Dict, Literal, Union
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 
 class ResponseFormatType(str, Enum):
@@ -52,13 +52,12 @@ class JsonSchemaResponseFormat(ResponseFormat):
         description="The JSON schema of the response.",
     )
 
-    @validator("json_schema")
-    def validate_json_schema(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+    @field_validator("json_schema")
+    @classmethod
+    def validate_json_schema(cls, v: dict[str, Any]) -> Dict[str, Any]:
         """Validate that the provided schema is a valid JSON schema."""
-        if not isinstance(v, dict):
-            raise ValueError("JSON schema must be a dictionary")
         if "schema" not in v:
-            raise ValueError("JSON schema should include a $schema property")
+            raise ValueError("JSON schema should include a schema property")
         return v
 
 

letta/schemas/tool_rule.py

@@ -3,7 +3,7 @@ import logging
 from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Union
 
 from jinja2 import Template
-from pydantic import Field
+from pydantic import Field, field_validator
 
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.letta_base import LettaBase
@@ -117,6 +117,13 @@ class ConditionalToolRule(BaseToolRule):
 
         return {self.default_child} if self.default_child else available_tools
 
+    @field_validator("child_output_mapping")
+    @classmethod
+    def validate_child_output_mapping(cls, v):
+        if len(v) == 0:
+            raise ValueError("Conditional tool rule must have at least one child tool.")
+        return v
+
     @staticmethod
     def _matches_key(function_output: str, key: Any) -> bool:
         """Helper function to determine if function output matches a mapping key."""

letta/services/agent_manager.py

@@ -1706,6 +1706,7 @@ class AgentManager:
         else:
             return agent_state
 
+    # Do not remove comment. (cliandy)
     # TODO: This is probably one of the worst pieces of code I've ever written please rip up as you see wish
     @enforce_types
     @trace_method
@@ -1715,7 +1716,6 @@ class AgentManager:
         actor: PydanticUser,
         force=False,
         update_timestamp=True,
-        tool_rules_solver: Optional[ToolRulesSolver] = None,
         dry_run: bool = False,
     ) -> Tuple[PydanticAgentState, Optional[PydanticMessage], int, int]:
         """Rebuilds the system message with the latest memory object and any shared memory block updates
@@ -1728,8 +1728,7 @@ class AgentManager:
         num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_id)
         agent_state = await self.get_agent_by_id_async(agent_id=agent_id, include_relationships=["memory", "sources", "tools"], actor=actor)
 
-        if not tool_rules_solver:
-            tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
+        tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
 
         curr_system_message = await self.message_manager.get_message_by_id_async(message_id=agent_state.message_ids[0], actor=actor)
 

letta/services/mcp/base_client.py

@@ -27,10 +27,14 @@ class AsyncBaseMCPClient:
             await self.session.initialize()
             self.initialized = True
         except ConnectionError as e:
-            logger.error(f"MCP connection failed: {str(e)}")
+            # MCP connection failures are often due to user misconfiguration, not system errors
+            # Log at debug level to avoid triggering Sentry alerts for expected configuration issues
+            logger.debug(f"MCP connection failed: {str(e)}")
             raise e
         except Exception as e:
-            logger.error(
+            # MCP connection failures are often due to user misconfiguration, not system errors
+            # Log at info level to help with debugging without triggering Sentry alerts
+            logger.info(
                 f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}. Error: {str(e)}"
             )
             if hasattr(self.server_config, "server_url") and self.server_config.server_url:

letta/services/mcp_manager.py

@@ -60,7 +60,9 @@ class MCPManager:
             tools = await mcp_client.list_tools()
             return tools
         except Exception as e:
-            logger.error(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+            # MCP tool listing errors are often due to connection/configuration issues, not system errors
+            # Log at info level to avoid triggering Sentry alerts for expected failures
+            logger.info(f"Error listing tools for MCP server {mcp_server_name}: {e}")
             return []
         finally:
             await mcp_client.cleanup()
@@ -302,7 +304,8 @@ class MCPManager:
                 try:
                     mcp_config = json.load(f)
                 except Exception as e:
-                    logger.error(f"Failed to parse MCP config file ({mcp_config_path}) as json: {e}")
+                    # Config parsing errors are user configuration issues, not system errors
+                    logger.warning(f"Failed to parse MCP config file ({mcp_config_path}) as json: {e}")
                     return mcp_server_list
 
                 # Proper formatting is "mcpServers" key at the top level,
@@ -313,7 +316,8 @@ class MCPManager:
 
                         # No support for duplicate server names
                         if server_name in mcp_server_list:
-                            logger.error(f"Duplicate MCP server name found (skipping): {server_name}")
+                            # Duplicate server names are configuration issues, not system errors
+                            logger.warning(f"Duplicate MCP server name found (skipping): {server_name}")
                             continue
 
                         if "url" in server_params_raw:
@@ -328,7 +332,8 @@ class MCPManager:
                                 )
                                 mcp_server_list[server_name] = server_params
                             except Exception as e:
-                                logger.error(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
+                                # Config parsing errors are user configuration issues, not system errors
+                                logger.warning(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
                                 continue
                         else:
                             # Attempt to parse the server params as a StdioServerParameters
@@ -341,7 +346,8 @@ class MCPManager:
                                 )
                                 mcp_server_list[server_name] = server_params
                             except Exception as e:
-                                logger.error(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
+                                # Config parsing errors are user configuration issues, not system errors
+                                logger.warning(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
                                 continue
         return mcp_server_list
 

letta/services/tool_executor/tool_execution_sandbox.py

@@ -224,8 +224,10 @@ class ToolExecutionSandbox:
             with open(temp_file_path, "r") as f:
                 code = f.read()
 
-            logger.error(f"Executing tool {self.tool_name} has process error: {e}")
-            logger.error(f"Logging out tool {self.tool_name} auto-generated code for debugging: \n\n{code}")
+            # Tool errors are expected behavior - tools can raise exceptions as part of their normal operation
+            # Only log at debug level to avoid triggering Sentry alerts for expected errors
+            logger.debug(f"Tool {self.tool_name} process error: {e}")
+            logger.debug(f"Tool {self.tool_name} auto-generated code for debugging: \n\n{code}")
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name,
                 exception_name=type(e).__name__,
@@ -371,8 +373,10 @@ class ToolExecutionSandbox:
                 },
             )
         elif execution.error:
-            logger.error(f"Executing tool {self.tool_name} raised a {execution.error.name} with message: \n{execution.error.value}")
-            logger.error(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
+            # Tool errors are expected behavior - tools can raise exceptions as part of their normal operation
+            # Only log at debug level to avoid triggering Sentry alerts for expected errors
+            logger.debug(f"Tool {self.tool_name} raised a {execution.error.name}: {execution.error.value}")
+            logger.debug(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name, exception_name=execution.error.name, exception_message=execution.error.value
             )

letta/services/tool_manager.py

@@ -410,32 +410,37 @@ class ToolManager:
         new_name = None
         new_schema = None
 
-        # TODO: Consider this behavior...is this what we want?
-        # TODO: I feel like it's bad if json_schema strays from source code so
-        # if source code is provided, always derive the name from it
-        if "source_code" in update_data.keys() and not bypass_name_check:
-            # derive the schema from source code to get the function name
-            derived_schema = derive_openai_json_schema(source_code=update_data["source_code"])
-            new_name = derived_schema["name"]
-
-            # if json_schema wasn't provided, use the derived schema
-            if "json_schema" not in update_data.keys():
-                new_schema = derived_schema
-            else:
-                # if json_schema was provided, update only its name to match the source code
-                new_schema = update_data["json_schema"].copy()
-                new_schema["name"] = new_name
-                # update the json_schema in update_data so it gets applied in the loop
-                update_data["json_schema"] = new_schema
+        # Fetch current tool to allow conditional logic based on tool type
+        current_tool = self.get_tool_by_id(tool_id=tool_id, actor=actor)
 
-            # get current tool to check if name is changing
-            current_tool = self.get_tool_by_id(tool_id=tool_id, actor=actor)
-            # check if the name is changing and if so, verify it doesn't conflict
+        # For MCP tools, do NOT derive schema from Python source. Trust provided JSON schema.
+        if current_tool.tool_type == ToolType.EXTERNAL_MCP:
+            if "json_schema" in update_data:
+                new_schema = update_data["json_schema"].copy()
+                new_name = new_schema.get("name", current_tool.name)
+            else:
+                new_schema = current_tool.json_schema
+                new_name = current_tool.name
+            update_data.pop("source_code", None)
             if new_name != current_tool.name:
-                # check if a tool with the new name already exists
                 existing_tool = self.get_tool_by_name(tool_name=new_name, actor=actor)
                 if existing_tool:
                     raise LettaToolNameConflictError(tool_name=new_name)
+        else:
+            # For non-MCP tools, preserve existing behavior
+            if "source_code" in update_data.keys() and not bypass_name_check:
+                derived_schema = derive_openai_json_schema(source_code=update_data["source_code"])
+                new_name = derived_schema["name"]
+                if "json_schema" not in update_data.keys():
+                    new_schema = derived_schema
+                else:
+                    new_schema = update_data["json_schema"].copy()
+                    new_schema["name"] = new_name
+                    update_data["json_schema"] = new_schema
+                if new_name != current_tool.name:
+                    existing_tool = self.get_tool_by_name(tool_name=new_name, actor=actor)
+                    if existing_tool:
+                        raise LettaToolNameConflictError(tool_name=new_name)
 
         # Now perform the update within the session
         with db_registry.session() as session:
@@ -473,32 +478,51 @@ class ToolManager:
         new_name = None
         new_schema = None
 
-        # TODO: Consider this behavior...is this what we want?
-        # TODO: I feel like it's bad if json_schema strays from source code so
-        # if source code is provided, always derive the name from it
-        if "source_code" in update_data.keys() and not bypass_name_check:
-            # derive the schema from source code to get the function name
-            derived_schema = derive_openai_json_schema(source_code=update_data["source_code"])
-            new_name = derived_schema["name"]
-
-            # if json_schema wasn't provided, use the derived schema
-            if "json_schema" not in update_data.keys():
-                new_schema = derived_schema
-            else:
-                # if json_schema was provided, update only its name to match the source code
-                new_schema = update_data["json_schema"].copy()
-                new_schema["name"] = new_name
-                # update the json_schema in update_data so it gets applied in the loop
-                update_data["json_schema"] = new_schema
+        # Fetch current tool early to allow conditional logic based on tool type
+        current_tool = await self.get_tool_by_id_async(tool_id=tool_id, actor=actor)
 
-            # get current tool to check if name is changing
-            current_tool = await self.get_tool_by_id_async(tool_id=tool_id, actor=actor)
-            # check if the name is changing and if so, verify it doesn't conflict
+        # For MCP tools, do NOT derive schema from Python source. Trust provided JSON schema.
+        if current_tool.tool_type == ToolType.EXTERNAL_MCP:
+            # Prefer provided json_schema; fall back to current
+            if "json_schema" in update_data:
+                new_schema = update_data["json_schema"].copy()
+                new_name = new_schema.get("name", current_tool.name)
+            else:
+                new_schema = current_tool.json_schema
+                new_name = current_tool.name
+            # Ensure we don't trigger derive
+            update_data.pop("source_code", None)
+            # If name changes, enforce uniqueness
             if new_name != current_tool.name:
-                # check if a tool with the new name already exists
                 name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
                 if name_exists:
                     raise LettaToolNameConflictError(tool_name=new_name)
+        else:
+            # For non-MCP tools, preserve existing behavior
+            # TODO: Consider this behavior...is this what we want?
+            # TODO: I feel like it's bad if json_schema strays from source code so
+            # if source code is provided, always derive the name from it
+            if "source_code" in update_data.keys() and not bypass_name_check:
+                # derive the schema from source code to get the function name
+                derived_schema = derive_openai_json_schema(source_code=update_data["source_code"])
+                new_name = derived_schema["name"]
+
+                # if json_schema wasn't provided, use the derived schema
+                if "json_schema" not in update_data.keys():
+                    new_schema = derived_schema
+                else:
+                    # if json_schema was provided, update only its name to match the source code
+                    new_schema = update_data["json_schema"].copy()
+                    new_schema["name"] = new_name
+                    # update the json_schema in update_data so it gets applied in the loop
+                    update_data["json_schema"] = new_schema
+
+                # check if the name is changing and if so, verify it doesn't conflict
+                if new_name != current_tool.name:
+                    # check if a tool with the new name already exists
+                    name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
+                    if name_exists:
+                        raise LettaToolNameConflictError(tool_name=new_name)
 
         # Now perform the update within the session
         async with db_registry.async_session() as session:

letta/services/tool_sandbox/e2b_sandbox.py

@@ -82,8 +82,10 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                     },
                 )
             elif execution.error:
-                logger.error(f"Executing tool {self.tool_name} raised a {execution.error.name} with message: \n{execution.error.value}")
-                logger.error(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
+                # Tool errors are expected behavior - tools can raise exceptions as part of their normal operation
+                # Only log at debug level to avoid triggering Sentry alerts for expected errors
+                logger.debug(f"Tool {self.tool_name} raised a {execution.error.name}: {execution.error.value}")
+                logger.debug(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
                 func_return = get_friendly_error_msg(
                     function_name=self.tool_name, exception_name=execution.error.name, exception_message=execution.error.value
                 )

letta/services/tool_sandbox/modal_sandbox.py

@@ -100,10 +100,10 @@ class AsyncToolSandboxModal(AsyncToolSandboxBase):
 
             # Process the result
             if result["error"]:
-                logger.error(
-                    f"Executing tool {self.tool_name} raised a {result['error']['name']} with message: \n{result['error']['value']}"
-                )
-                logger.error(f"Traceback from Modal sandbox: \n{result['error']['traceback']}")
+                # Tool errors are expected behavior - tools can raise exceptions as part of their normal operation
+                # Only log at debug level to avoid triggering Sentry alerts for expected errors
+                logger.debug(f"Tool {self.tool_name} raised a {result['error']['name']}: {result['error']['value']}")
+                logger.debug(f"Traceback from Modal sandbox: \n{result['error']['traceback']}")
                 func_return = get_friendly_error_msg(
                     function_name=self.tool_name, exception_name=result["error"]["name"], exception_message=result["error"]["value"]
                 )

letta/settings.py

@@ -144,6 +144,7 @@ class ModelSettings(BaseSettings):
     # google ai
     gemini_api_key: Optional[str] = None
     gemini_base_url: str = "https://generativelanguage.googleapis.com/"
+    gemini_force_minimum_thinking_budget: bool = False
 
     # google vertex
     google_cloud_project: Optional[str] = None
@@ -200,7 +201,7 @@ class DatabaseChoice(str, Enum):
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="letta_", extra="ignore")
 
-    letta_dir: Optional[Path] = Field(Path.home() / ".letta", env="LETTA_DIR")
+    letta_dir: Optional[Path] = Field(Path.home() / ".letta", alias="LETTA_DIR")
     debug: Optional[bool] = False
     cors_origins: Optional[list] = cors_origins
 

{letta_nightly-0.11.2.dev20250811104433.dist-info → letta_nightly-0.11.3.dev20250812002120.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.11.2.dev20250811104433
+Version: 0.11.3.dev20250812002120
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team