letta-nightly 0.11.3.dev20250820104219__py3-none-any.whl → 0.11.4.dev20250820213507__py3-none-any.whl

letta/services/step_manager.py

@@ -11,11 +11,13 @@ from letta.orm.errors import NoResultFound
 from letta.orm.job import Job as JobModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
+from letta.orm.step_metrics import StepMetrics as StepMetricsModel
 from letta.otel.tracing import get_trace_id, trace_method
 from letta.schemas.enums import StepStatus
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.step import Step as PydanticStep
+from letta.schemas.step_metrics import StepMetrics as PydanticStepMetrics
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.utils import enforce_types
@@ -187,6 +189,13 @@ class StepManager:
             step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
             return step.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def get_step_metrics_async(self, step_id: str, actor: PydanticUser) -> PydanticStepMetrics:
+        async with db_registry.async_session() as session:
+            metrics = await StepMetricsModel.read_async(db_session=session, identifier=step_id, actor=actor)
+            return metrics.to_pydantic()
+
     @enforce_types
     @trace_method
     async def add_feedback_async(self, step_id: str, feedback: Optional[FeedbackType], actor: PydanticUser) -> PydanticStep:
@@ -372,6 +381,65 @@ class StepManager:
             await session.commit()
             return step.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def record_step_metrics_async(
+        self,
+        actor: PydanticUser,
+        step_id: str,
+        llm_request_ns: Optional[int] = None,
+        tool_execution_ns: Optional[int] = None,
+        step_ns: Optional[int] = None,
+        agent_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        template_id: Optional[str] = None,
+        base_template_id: Optional[str] = None,
+    ) -> PydanticStepMetrics:
+        """Record performance metrics for a step.
+
+        Args:
+            actor: The user making the request
+            step_id: The ID of the step to record metrics for
+            llm_request_ns: Time spent on LLM request in nanoseconds
+            tool_execution_ns: Time spent on tool execution in nanoseconds
+            step_ns: Total time for the step in nanoseconds
+            agent_id: The ID of the agent
+            job_id: The ID of the job
+            project_id: The ID of the project
+            template_id: The ID of the template
+            base_template_id: The ID of the base template
+
+        Returns:
+            The created step metrics
+
+        Raises:
+            NoResultFound: If the step does not exist
+        """
+        async with db_registry.async_session() as session:
+            step = await session.get(StepModel, step_id)
+            if not step:
+                raise NoResultFound(f"Step with id {step_id} does not exist")
+            if step.organization_id != actor.organization_id:
+                raise Exception("Unauthorized")
+
+            metrics_data = {
+                "id": step_id,
+                "organization_id": actor.organization_id,
+                "agent_id": agent_id or step.agent_id,
+                "job_id": job_id or step.job_id,
+                "project_id": project_id or step.project_id,
+                "llm_request_ns": llm_request_ns,
+                "tool_execution_ns": tool_execution_ns,
+                "step_ns": step_ns,
+                "template_id": template_id,
+                "base_template_id": base_template_id,
+            }
+
+            metrics = StepMetricsModel(**metrics_data)
+            await metrics.create_async(session)
+            return metrics.to_pydantic()
+
     def _verify_job_access(
         self,
         session: Session,

letta/services/summarizer/summarizer.py

@@ -348,12 +348,9 @@ async def simple_summary(messages: List[Message], llm_config: LLMConfig, actor:
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": summary_transcript},
         ]
-    print("messages going to summarizer:", input_messages)
     input_messages_obj = [simple_message_wrapper(msg) for msg in input_messages]
-    print("messages going to summarizer (objs):", input_messages_obj)
-
     request_data = llm_client.build_request_data(input_messages_obj, llm_config, tools=[])
-    print("request data:", request_data)
+
     # NOTE: we should disable the inner_thoughts_in_kwargs here, because we don't use it
     # I'm leaving it commented it out for now for safety but is fine assuming the var here is a copy not a reference
     # llm_config.put_inner_thoughts_in_kwargs = False

letta/services/tool_executor/core_tool_executor.py

@@ -174,7 +174,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        await PassageManager().insert_passage_async(
+        await PassageManager().insert_passage(
             agent_state=agent_state,
             text=content,
             actor=actor,

letta/services/tool_executor/sandbox_tool_executor.py

@@ -5,7 +5,7 @@ from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_fun
 from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import SandboxType
+from letta.schemas.enums import SandboxType, ToolSourceType
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
@@ -19,11 +19,6 @@ from letta.utils import get_friendly_error_msg
 
 logger = get_logger(__name__)
 
-if tool_settings.e2b_api_key:
-    from letta.services.tool_sandbox.e2b_sandbox import AsyncToolSandboxE2B
-if tool_settings.modal_api_key:
-    from letta.services.tool_sandbox.modal_sandbox import AsyncToolSandboxModal
-
 
 class SandboxToolExecutor(ToolExecutor):
     """Executor for sandboxed tools."""
@@ -54,13 +49,35 @@ class SandboxToolExecutor(ToolExecutor):
 
             # Execute in sandbox depending on API key
             if tool_settings.sandbox_type == SandboxType.E2B:
+                from letta.services.tool_sandbox.e2b_sandbox import AsyncToolSandboxE2B
+
                 sandbox = AsyncToolSandboxE2B(
                     function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
                 )
+            # TODO (cliandy): this is just for testing right now, separate this out into it's own subclass and handling logic
             elif tool_settings.sandbox_type == SandboxType.MODAL:
-                sandbox = AsyncToolSandboxModal(
-                    function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
-                )
+                from letta.services.tool_sandbox.modal_sandbox import AsyncToolSandboxModal, TypescriptToolSandboxModal
+
+                if tool.source_type == ToolSourceType.typescript:
+                    sandbox = TypescriptToolSandboxModal(
+                        function_name,
+                        function_args,
+                        actor,
+                        tool_object=tool,
+                        sandbox_config=sandbox_config,
+                        sandbox_env_vars=sandbox_env_vars,
+                    )
+                elif tool.source_type == ToolSourceType.python:
+                    sandbox = AsyncToolSandboxModal(
+                        function_name,
+                        function_args,
+                        actor,
+                        tool_object=tool,
+                        sandbox_config=sandbox_config,
+                        sandbox_env_vars=sandbox_env_vars,
+                    )
+                else:
+                    raise ValueError(f"Tool source type was {tool.source_type} but is required to be python or typescript to run in Modal.")
             else:
                 sandbox = AsyncToolSandboxLocal(
                     function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars

letta/services/tool_manager.py

@@ -404,7 +404,37 @@ class ToolManager:
         updated_tool_type: Optional[ToolType] = None,
         bypass_name_check: bool = False,
     ) -> PydanticTool:
-        """Update a tool by its ID with the given ToolUpdate object."""
+        """
+        Update a tool with complex validation and schema derivation logic.
+
+        This method handles updates differently based on tool type:
+        - MCP tools: JSON schema is trusted, no Python source derivation
+        - Python/TypeScript tools: Schema derived from source code if provided
+        - Name conflicts are checked unless bypassed
+
+        Args:
+            tool_id: The UUID of the tool to update
+            tool_update: Partial update data (only changed fields)
+            actor: User performing the update (for permissions)
+            updated_tool_type: Optional new tool type (e.g., converting custom to builtin)
+            bypass_name_check: Skip name conflict validation (use with caution)
+
+        Returns:
+            Updated tool as Pydantic model
+
+        Raises:
+            LettaToolNameConflictError: If new name conflicts with existing tool
+            NoResultFound: If tool doesn't exist or user lacks access
+
+        Side Effects:
+            - Updates tool in database
+            - May change tool name if source code is modified
+            - Recomputes JSON schema from source for non-MCP tools
+
+        Important:
+            When source_code is provided for Python/TypeScript tools, the name
+            MUST match the function name in the code, overriding any name in json_schema
+        """
         # First, check if source code update would cause a name conflict
         update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
         new_name = None
@@ -429,7 +459,16 @@ class ToolManager:
         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"])
+                # Check source type to use appropriate parser
+                source_type = update_data.get("source_type", current_tool.source_type)
+                if source_type == "typescript":
+                    from letta.functions.typescript_parser import derive_typescript_json_schema
+
+                    derived_schema = derive_typescript_json_schema(source_code=update_data["source_code"])
+                else:
+                    # Default to Python for backwards compatibility
+                    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
@@ -503,8 +542,15 @@ class ToolManager:
             # 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"])
+                # Check source type to use appropriate parser
+                source_type = update_data.get("source_type", current_tool.source_type)
+                if source_type == "typescript":
+                    from letta.functions.typescript_parser import derive_typescript_json_schema
+
+                    derived_schema = derive_typescript_json_schema(source_code=update_data["source_code"])
+                else:
+                    # Default to Python for backwards compatibility
+                    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
@@ -570,7 +616,38 @@ class ToolManager:
     @enforce_types
     @trace_method
     def upsert_base_tools(self, actor: PydanticUser) -> List[PydanticTool]:
-        """Add default tools in base.py and multi_agent.py"""
+        """
+        Initialize or update all built-in Letta tools for a user.
+
+        This method scans predefined modules to discover and register all base tools
+        that ship with Letta. Tools are categorized by type (core, memory, multi-agent, etc.)
+        and tagged appropriately for filtering.
+
+        Args:
+            actor: The user to create/update tools for
+
+        Returns:
+            List of all base tools that were created or updated
+
+        Tool Categories Created:
+            - LETTA_CORE: Basic conversation tools (send_message)
+            - LETTA_MEMORY_CORE: Memory management (core_memory_append/replace)
+            - LETTA_MULTI_AGENT_CORE: Multi-agent communication tools
+            - LETTA_SLEEPTIME_CORE: Sleeptime agent tools
+            - LETTA_VOICE_SLEEPTIME_CORE: Voice agent specific tools
+            - LETTA_BUILTIN: Additional built-in utilities
+            - LETTA_FILES_CORE: File handling tools
+
+        Side Effects:
+            - Creates or updates tools in database
+            - Tools are marked with appropriate type and tags
+            - Existing custom tools with same names are NOT overwritten
+
+        Note:
+            This is typically called during user initialization or system upgrade
+            to ensure all base tools are available. Custom tools take precedence
+            over base tools with the same name.
+        """
         functions_to_schema = {}
 
         for module_name in LETTA_TOOL_MODULE_NAMES:

letta/services/tool_sandbox/base.py

@@ -164,22 +164,14 @@ class AsyncToolSandboxBase(ABC):
         import ast
 
         try:
-            # Parse the source code to AST
             tree = ast.parse(self.tool.source_code)
 
-            # Look for function definitions
             for node in ast.walk(tree):
                 if isinstance(node, ast.AsyncFunctionDef) and node.name == self.tool.name:
                     return True
-                elif isinstance(node, ast.FunctionDef) and node.name == self.tool.name:
-                    return False
-
-            # If we couldn't find the function definition, fall back to string matching
-            return "async def " + self.tool.name in self.tool.source_code
-
-        except SyntaxError:
-            # If source code can't be parsed, fall back to string matching
-            return "async def " + self.tool.name in self.tool.source_code
+            return False
+        except:
+            return False
 
     def use_top_level_await(self) -> bool:
         """

letta/services/tool_sandbox/modal_constants.py

@@ -0,0 +1,17 @@
+"""Shared constants for Modal sandbox implementations."""
+
+# Deployment and versioning
+DEFAULT_CONFIG_KEY = "default"
+MODAL_DEPLOYMENTS_KEY = "modal_deployments"
+VERSION_HASH_LENGTH = 12
+
+# Cache settings
+CACHE_TTL_SECONDS = 60
+
+# Modal execution settings
+DEFAULT_MODAL_TIMEOUT = 60
+DEFAULT_MAX_CONCURRENT_INPUTS = 1
+DEFAULT_PYTHON_VERSION = "3.12"
+
+# Security settings
+SAFE_IMPORT_MODULES = {"typing", "pydantic", "datetime", "enum", "uuid", "decimal"}

letta/services/tool_sandbox/modal_deployment_manager.py

@@ -0,0 +1,242 @@
+"""
+Modal Deployment Manager - Handles deployment orchestration with optional locking.
+
+This module separates deployment logic from the main sandbox execution,
+making it easier to understand and optionally disable locking/version tracking.
+"""
+
+import hashlib
+from typing import Tuple
+
+import modal
+
+from letta.log import get_logger
+from letta.schemas.sandbox_config import SandboxConfig
+from letta.schemas.tool import Tool
+from letta.services.tool_sandbox.modal_constants import VERSION_HASH_LENGTH
+from letta.services.tool_sandbox.modal_version_manager import ModalVersionManager, get_version_manager
+
+logger = get_logger(__name__)
+
+
+class ModalDeploymentManager:
+    """Manages Modal app deployments with optional locking and version tracking."""
+
+    def __init__(
+        self,
+        tool: Tool,
+        version_manager: ModalVersionManager | None = None,
+        use_locking: bool = True,
+        use_version_tracking: bool = True,
+    ):
+        """
+        Initialize deployment manager.
+
+        Args:
+            tool: The tool to deploy
+            version_manager: Version manager for tracking deployments (optional)
+            use_locking: Whether to use locking for coordinated deployments
+            use_version_tracking: Whether to track and reuse existing deployments
+        """
+        self.tool = tool
+        self.version_manager = version_manager or get_version_manager() if (use_locking or use_version_tracking) else None
+        self.use_locking = use_locking
+        self.use_version_tracking = use_version_tracking
+        self._app_name = self._generate_app_name()
+
+    def _generate_app_name(self) -> str:
+        """Generate app name based on tool ID."""
+        return self.tool.id[:40]
+
+    def calculate_version_hash(self, sbx_config: SandboxConfig) -> str:
+        """Calculate version hash for the current configuration."""
+        components = (
+            self.tool.source_code,
+            str(self.tool.pip_requirements) if self.tool.pip_requirements else "",
+            str(self.tool.npm_requirements) if self.tool.npm_requirements else "",
+            sbx_config.fingerprint(),
+        )
+        combined = "|".join(components)
+        return hashlib.sha256(combined.encode()).hexdigest()[:VERSION_HASH_LENGTH]
+
+    def get_full_app_name(self, version_hash: str) -> str:
+        """Get the full app name including version."""
+        app_full_name = f"{self._app_name}-{version_hash}"
+        # Ensure total length is under 64 characters
+        if len(app_full_name) > 63:
+            max_id_len = 63 - len(version_hash) - 1
+            app_full_name = f"{self._app_name[:max_id_len]}-{version_hash}"
+        return app_full_name
+
+    async def get_or_deploy_app(
+        self,
+        sbx_config: SandboxConfig,
+        user,
+        create_app_func,
+    ) -> Tuple[modal.App, str]:
+        """
+        Get existing app or deploy new one.
+
+        Args:
+            sbx_config: Sandbox configuration
+            user: User/actor for permissions
+            create_app_func: Function to create and deploy the app
+
+        Returns:
+            Tuple of (Modal app, version hash)
+        """
+        version_hash = self.calculate_version_hash(sbx_config)
+
+        # Simple path: no version tracking or locking
+        if not self.use_version_tracking:
+            logger.info(f"Deploying Modal app {self._app_name} (version tracking disabled)")
+            app = await create_app_func(sbx_config, version_hash)
+            return app, version_hash
+
+        # Try to use existing deployment
+        if self.use_version_tracking:
+            existing_app = await self._try_get_existing_app(sbx_config, version_hash, user)
+            if existing_app:
+                return existing_app, version_hash
+
+        # Need to deploy - with or without locking
+        if self.use_locking:
+            return await self._deploy_with_locking(sbx_config, version_hash, user, create_app_func)
+        else:
+            return await self._deploy_without_locking(sbx_config, version_hash, user, create_app_func)
+
+    async def _try_get_existing_app(
+        self,
+        sbx_config: SandboxConfig,
+        version_hash: str,
+        user,
+    ) -> modal.App | None:
+        """Try to get an existing deployed app."""
+        if not self.version_manager:
+            return None
+
+        deployment = await self.version_manager.get_deployment(
+            tool_id=self.tool.id, sandbox_config_id=sbx_config.id if sbx_config else None, actor=user
+        )
+
+        if deployment and deployment.version_hash == version_hash:
+            app_full_name = self.get_full_app_name(version_hash)
+            logger.info(f"Checking for existing Modal app {app_full_name}")
+
+            try:
+                app = await modal.App.lookup.aio(app_full_name)
+                logger.info(f"Found existing Modal app {app_full_name}")
+                return app
+            except Exception:
+                logger.info(f"Modal app {app_full_name} not found in Modal, will redeploy")
+                return None
+
+        return None
+
+    async def _deploy_without_locking(
+        self,
+        sbx_config: SandboxConfig,
+        version_hash: str,
+        user,
+        create_app_func,
+    ) -> Tuple[modal.App, str]:
+        """Deploy without locking - simpler but may have race conditions."""
+        app_full_name = self.get_full_app_name(version_hash)
+        logger.info(f"Deploying Modal app {app_full_name} (no locking)")
+
+        # Deploy the app
+        app = await create_app_func(sbx_config, version_hash)
+
+        # Register deployment if tracking is enabled
+        if self.use_version_tracking and self.version_manager:
+            await self._register_deployment(sbx_config, version_hash, app, user)
+
+        return app, version_hash
+
+    async def _deploy_with_locking(
+        self,
+        sbx_config: SandboxConfig,
+        version_hash: str,
+        user,
+        create_app_func,
+    ) -> Tuple[modal.App, str]:
+        """Deploy with locking to prevent concurrent deployments."""
+        cache_key = f"{self.tool.id}:{sbx_config.id if sbx_config else 'default'}"
+        deployment_lock = self.version_manager.get_deployment_lock(cache_key)
+
+        async with deployment_lock:
+            # Double-check after acquiring lock
+            existing_app = await self._try_get_existing_app(sbx_config, version_hash, user)
+            if existing_app:
+                return existing_app, version_hash
+
+            # Check if another process is deploying
+            if self.version_manager.is_deployment_in_progress(cache_key, version_hash):
+                logger.info(f"Another process is deploying {self._app_name} v{version_hash}, waiting...")
+                # Release lock and wait
+                deployment_lock = None
+
+        # Wait for other deployment if needed
+        if deployment_lock is None:
+            success = await self.version_manager.wait_for_deployment(cache_key, version_hash, timeout=120)
+            if success:
+                existing_app = await self._try_get_existing_app(sbx_config, version_hash, user)
+                if existing_app:
+                    return existing_app, version_hash
+                raise RuntimeError(f"Deployment completed but app not found")
+            else:
+                raise RuntimeError(f"Timeout waiting for deployment")
+
+        # We're deploying - mark as in progress
+        deployment_key = None
+        async with deployment_lock:
+            deployment_key = self.version_manager.mark_deployment_in_progress(cache_key, version_hash)
+
+        try:
+            app_full_name = self.get_full_app_name(version_hash)
+            logger.info(f"Deploying Modal app {app_full_name} with locking")
+
+            # Deploy the app
+            app = await create_app_func(sbx_config, version_hash)
+
+            # Mark deployment complete
+            if deployment_key:
+                self.version_manager.complete_deployment(deployment_key)
+
+            # Register deployment
+            if self.use_version_tracking:
+                await self._register_deployment(sbx_config, version_hash, app, user)
+
+            return app, version_hash
+
+        except Exception:
+            if deployment_key:
+                self.version_manager.complete_deployment(deployment_key)
+            raise
+
+    async def _register_deployment(
+        self,
+        sbx_config: SandboxConfig,
+        version_hash: str,
+        app: modal.App,
+        user,
+    ):
+        if not self.version_manager:
+            return
+
+        dependencies = set()
+        if self.tool.pip_requirements:
+            dependencies.update(str(req) for req in self.tool.pip_requirements)
+        modal_config = sbx_config.get_modal_config()
+        if modal_config.pip_requirements:
+            dependencies.update(str(req) for req in modal_config.pip_requirements)
+
+        await self.version_manager.register_deployment(
+            tool_id=self.tool.id,
+            app_name=self._app_name,
+            version_hash=version_hash,
+            app=app,
+            dependencies=dependencies,
+            sandbox_config_id=sbx_config.id if sbx_config else None,
+            actor=user,
+        )