letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.3.dev20250607000559__py3-none-any.whl

letta/services/tool_executor/tool_executor_base.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from letta.schemas.agent import AgentState
+from letta.schemas.sandbox_config import SandboxConfig
+from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+
+
+class ToolExecutor(ABC):
+    """Abstract base class for tool executors."""
+
+    def __init__(
+        self,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        passage_manager: PassageManager,
+        actor: User,
+    ):
+        self.message_manager = message_manager
+        self.agent_manager = agent_manager
+        self.block_manager = block_manager
+        self.passage_manager = passage_manager
+        self.actor = actor
+
+    @abstractmethod
+    async def execute(
+        self,
+        function_name: str,
+        function_args: dict,
+        tool: Tool,
+        actor: User,
+        agent_state: Optional[AgentState] = None,
+        sandbox_config: Optional[SandboxConfig] = None,
+        sandbox_env_vars: Optional[Dict[str, Any]] = None,
+    ) -> ToolExecutionResult:
+        """Execute the tool and return the result."""

letta/services/tool_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 import importlib
 import warnings
-from typing import List, Optional, Union
+from typing import List, Optional, Set, Union
 
 from letta.constants import (
     BASE_FUNCTION_RETURN_CHAR_LIMIT,
@@ -11,6 +11,8 @@ from letta.constants import (
     BASE_VOICE_SLEEPTIME_CHAT_TOOLS,
     BASE_VOICE_SLEEPTIME_TOOLS,
     BUILTIN_TOOLS,
+    FILES_TOOLS,
+    LETTA_TOOL_MODULE_NAMES,
     LETTA_TOOL_SET,
     MCP_TOOL_TAG_NAME_PREFIX,
     MULTI_AGENT_TOOLS,
@@ -22,12 +24,12 @@ from letta.orm.enums import ToolType
 # TODO: Remove this once we translate all of these to the ORM
 from letta.orm.errors import NoResultFound
 from letta.orm.tool import Tool as ToolModel
+from letta.otel.tracing import trace_method
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.mcp.types import SSEServerConfig, StdioServerConfig
-from letta.tracing import trace_method
 from letta.utils import enforce_types, printd
 
 logger = get_logger(__name__)
@@ -368,12 +370,10 @@ class ToolManager:
     def upsert_base_tools(self, actor: PydanticUser) -> List[PydanticTool]:
         """Add default tools in base.py and multi_agent.py"""
         functions_to_schema = {}
-        module_names = ["base", "multi_agent", "voice", "builtin"]
 
-        for module_name in module_names:
-            full_module_name = f"letta.functions.function_sets.{module_name}"
+        for module_name in LETTA_TOOL_MODULE_NAMES:
             try:
-                module = importlib.import_module(full_module_name)
+                module = importlib.import_module(module_name)
             except Exception as e:
                 # Handle other general exceptions
                 raise e
@@ -407,6 +407,9 @@ class ToolManager:
                 elif name in BUILTIN_TOOLS:
                     tool_type = ToolType.LETTA_BUILTIN
                     tags = [tool_type.value]
+                elif name in FILES_TOOLS:
+                    tool_type = ToolType.LETTA_FILES_CORE
+                    tags = [tool_type.value]
                 else:
                     raise ValueError(
                         f"Tool name {name} is not in the list of base tool names: {BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_CHAT_TOOLS}"
@@ -431,66 +434,59 @@ class ToolManager:
 
     @enforce_types
     @trace_method
-    async def upsert_base_tools_async(self, actor: PydanticUser) -> List[PydanticTool]:
-        """Add default tools in base.py and multi_agent.py"""
-        functions_to_schema = {}
-        module_names = ["base", "multi_agent", "voice", "builtin"]
-
-        for module_name in module_names:
-            full_module_name = f"letta.functions.function_sets.{module_name}"
-            try:
-                module = importlib.import_module(full_module_name)
-            except Exception as e:
-                # Handle other general exceptions
-                raise e
+    async def upsert_base_tools_async(
+        self,
+        actor: PydanticUser,
+        allowed_types: Optional[Set[ToolType]] = None,
+    ) -> List[PydanticTool]:
+        """Add default tools defined in the various function_sets modules, optionally filtered by ToolType."""
 
+        functions_to_schema = {}
+        for module_name in LETTA_TOOL_MODULE_NAMES:
             try:
-                # Load the function set
+                module = importlib.import_module(module_name)
                 functions_to_schema.update(load_function_set(module))
             except ValueError as e:
-                err = f"Error loading function set '{module_name}': {e}"
-                warnings.warn(err)
+                warnings.warn(f"Error loading function set '{module_name}': {e}")
+            except Exception as e:
+                raise e
 
-        # create tool in db
         tools = []
         for name, schema in functions_to_schema.items():
-            if name in LETTA_TOOL_SET:
-                if name in BASE_TOOLS:
-                    tool_type = ToolType.LETTA_CORE
-                    tags = [tool_type.value]
-                elif name in BASE_MEMORY_TOOLS:
-                    tool_type = ToolType.LETTA_MEMORY_CORE
-                    tags = [tool_type.value]
-                elif name in MULTI_AGENT_TOOLS:
-                    tool_type = ToolType.LETTA_MULTI_AGENT_CORE
-                    tags = [tool_type.value]
-                elif name in BASE_SLEEPTIME_TOOLS:
-                    tool_type = ToolType.LETTA_SLEEPTIME_CORE
-                    tags = [tool_type.value]
-                elif name in BASE_VOICE_SLEEPTIME_TOOLS or name in BASE_VOICE_SLEEPTIME_CHAT_TOOLS:
-                    tool_type = ToolType.LETTA_VOICE_SLEEPTIME_CORE
-                    tags = [tool_type.value]
-                elif name in BUILTIN_TOOLS:
-                    tool_type = ToolType.LETTA_BUILTIN
-                    tags = [tool_type.value]
-                else:
-                    raise ValueError(
-                        f"Tool name {name} is not in the list of base tool names: {BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_CHAT_TOOLS}"
-                    )
-
-                # create to tool
-                tools.append(
-                    self.create_or_update_tool_async(
-                        PydanticTool(
-                            name=name,
-                            tags=tags,
-                            source_type="python",
-                            tool_type=tool_type,
-                            return_char_limit=BASE_FUNCTION_RETURN_CHAR_LIMIT,
-                        ),
-                        actor=actor,
-                    )
+            if name not in LETTA_TOOL_SET:
+                continue
+
+            if name in BASE_TOOLS:
+                tool_type = ToolType.LETTA_CORE
+            elif name in BASE_MEMORY_TOOLS:
+                tool_type = ToolType.LETTA_MEMORY_CORE
+            elif name in BASE_SLEEPTIME_TOOLS:
+                tool_type = ToolType.LETTA_SLEEPTIME_CORE
+            elif name in MULTI_AGENT_TOOLS:
+                tool_type = ToolType.LETTA_MULTI_AGENT_CORE
+            elif name in BASE_VOICE_SLEEPTIME_TOOLS or name in BASE_VOICE_SLEEPTIME_CHAT_TOOLS:
+                tool_type = ToolType.LETTA_VOICE_SLEEPTIME_CORE
+            elif name in BUILTIN_TOOLS:
+                tool_type = ToolType.LETTA_BUILTIN
+            elif name in FILES_TOOLS:
+                tool_type = ToolType.LETTA_FILES_CORE
+            else:
+                raise ValueError(f"Tool name {name} is not recognized in any known base tool set.")
+
+            if allowed_types is not None and tool_type not in allowed_types:
+                continue
+
+            tools.append(
+                self.create_or_update_tool_async(
+                    PydanticTool(
+                        name=name,
+                        tags=[tool_type.value],
+                        source_type="python",
+                        tool_type=tool_type,
+                        return_char_limit=BASE_FUNCTION_RETURN_CHAR_LIMIT,
+                    ),
+                    actor=actor,
                 )
+            )
 
-        # TODO: Delete any base tools that are stale
         return await asyncio.gather(*tools)

letta/services/tool_sandbox/e2b_sandbox.py

@@ -3,13 +3,13 @@ from typing import TYPE_CHECKING, Any, Dict, Optional
 from e2b_code_interpreter import AsyncSandbox
 
 from letta.log import get_logger
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
-from letta.tracing import log_event, trace_method
 from letta.types import JsonDict
 from letta.utils import get_friendly_error_msg
 

letta/services/tool_sandbox/local_sandbox.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Optional
 
 from pydantic.config import JsonDict
 
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
@@ -20,7 +21,6 @@ from letta.services.helpers.tool_execution_helper import (
 from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.settings import tool_settings
-from letta.tracing import log_event, trace_method
 from letta.utils import get_friendly_error_msg, parse_stderr_error_msg
 
 
@@ -152,8 +152,11 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             print(f"Auto-generated code for debugging:\n\n{code}")
             raise e
         finally:
-            # Clean up the temp file
-            os.remove(temp_file_path)
+            # Clean up the temp file if not debugging
+            from letta.settings import settings
+
+            if not settings.debug:
+                os.remove(temp_file_path)
 
     async def _prepare_venv(self, local_configs, venv_path: str, env: Dict[str, str]):
         """

letta/services/user_manager.py

@@ -5,12 +5,13 @@ from sqlalchemy import select, text
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
+from letta.otel.tracing import trace_method
 from letta.schemas.user import User as PydanticUser
 from letta.schemas.user import UserUpdate
 from letta.server.db import db_registry
 from letta.services.organization_manager import OrganizationManager
-from letta.tracing import trace_method
 from letta.utils import enforce_types
+from letta.settings import settings
 
 
 class UserManager:
@@ -147,13 +148,15 @@ class UserManager:
         """Fetch a user by ID asynchronously."""
         async with db_registry.async_session() as session:
             # Turn off seqscan to force use pk index
-            await session.execute(text("SET LOCAL enable_seqscan = OFF"))
+            if settings.letta_pg_uri_no_default:
+                await session.execute(text("SET LOCAL enable_seqscan = OFF"))
             try:
                 stmt = select(UserModel).where(UserModel.id == actor_id)
                 result = await session.execute(stmt)
                 user = result.scalar_one_or_none()
             finally:
-                await session.execute(text("SET LOCAL enable_seqscan = ON"))
+                if settings.letta_pg_uri_no_default:
+                    await session.execute(text("SET LOCAL enable_seqscan = ON"))
 
             if not user:
                 raise NoResultFound(f"User not found with id={actor_id}")

letta/settings.py

@@ -28,7 +28,8 @@ class ToolSettings(BaseSettings):
     mcp_connect_to_server_timeout: float = 30.0
     mcp_list_tools_timeout: float = 30.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
+    mcp_read_from_config: bool = False  # if False, will throw if attempting to read/write from file
+    mcp_disable_stdio: bool = False
 
 
 class SummarizerSettings(BaseSettings):
@@ -192,13 +193,17 @@ class Settings(BaseSettings):
     pool_use_lifo: bool = True
     disable_sqlalchemy_pooling: bool = False
 
+    redis_host: Optional[str] = None
+    redis_port: Optional[int] = None
+
+    plugin_register: Optional[str] = None
+
     # multi agent settings
     multi_agent_send_message_max_retries: int = 3
     multi_agent_send_message_timeout: int = 20 * 60
     multi_agent_concurrent_sends: int = 50
 
     # telemetry logging
-    verbose_telemetry_logging: bool = False
     otel_exporter_otlp_endpoint: Optional[str] = None  # otel default: "http://localhost:4317"
     disable_tracing: bool = False
     llm_api_logging: bool = True
@@ -210,6 +215,7 @@ class Settings(BaseSettings):
 
     use_uvloop: bool = False
     use_granian: bool = False
+    sqlalchemy_tracing: bool = False
 
     # event loop parallelism
     event_loop_threadpool_max_workers: int = 43
@@ -258,6 +264,15 @@ class Settings(BaseSettings):
         else:
             return None
 
+    @property
+    def plugin_register_dict(self) -> dict:
+        plugins = {}
+        if self.plugin_register:
+            for plugin in self.plugin_register.split(";"):
+                name, target = plugin.split("=")
+                plugins[name] = {"target": target}
+        return plugins
+
 
 class TestSettings(Settings):
     model_config = SettingsConfigDict(env_prefix="letta_test_", extra="ignore")
@@ -265,9 +280,15 @@ class TestSettings(Settings):
     letta_dir: Optional[Path] = Field(Path.home() / ".letta/test", env="LETTA_TEST_DIR")
 
 
+class LogSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="letta_logging_", extra="ignore")
+    verbose_telemetry_logging: bool = False
+
+
 # singleton
 settings = Settings(_env_parse_none_str="None")
 test_settings = TestSettings()
 model_settings = ModelSettings()
 tool_settings = ToolSettings()
 summarizer_settings = SummarizerSettings()
+log_settings = LogSettings()

letta/utils.py

@@ -515,6 +515,11 @@ def is_optional_type(hint):
 
 
 def enforce_types(func):
+    """Enforces that values passed in match the expected types.
+
+    Technically will handle coroutines as well.
+    """
+
     @wraps(func)
     def wrapper(*args, **kwargs):
         # Get type hints, excluding the return type hint
@@ -1078,9 +1083,9 @@ def log_telemetry(logger: Logger, event: str, **kwargs):
     :param event: A string describing the event.
     :param kwargs: Additional key-value pairs for logging metadata.
     """
-    from letta.settings import settings
+    from letta.settings import log_settings
 
-    if settings.verbose_telemetry_logging:
+    if log_settings.verbose_telemetry_logging:
         timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S,%f UTC")  # More readable timestamp
         extra_data = " | ".join(f"{key}={value}" for key, value in kwargs.items() if value is not None)
         logger.info(f"[{timestamp}] EVENT: {event} | {extra_data}")

{letta_nightly-0.8.0.dev20250606195656.dist-info → letta_nightly-0.8.3.dev20250607000559.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.0.dev20250606195656
+Version: 0.8.3.dev20250607000559
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -21,6 +21,7 @@ Provides-Extra: external-tools
 Provides-Extra: google
 Provides-Extra: postgres
 Provides-Extra: qdrant
+Provides-Extra: redis
 Provides-Extra: server
 Provides-Extra: tests
 Requires-Dist: aiomultiprocess (>=0.9.1,<0.10.0)
@@ -55,7 +56,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.143,<0.2.0)
+Requires-Dist: letta_client (>=0.1.147,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
@@ -90,6 +91,7 @@ Requires-Dist: pytz (>=2023.3.post1,<2024.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: qdrant-client (>=1.9.1,<2.0.0) ; extra == "qdrant"
 Requires-Dist: questionary (>=2.0.1,<3.0.0)
+Requires-Dist: redis (>=6.2.0,<7.0.0) ; extra == "redis" or extra == "all"
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: sentry-sdk[fastapi] (==2.19.1)
 Requires-Dist: setuptools (>=70,<71)