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

letta/services/tool_sandbox/modal_version_manager.py

@@ -0,0 +1,273 @@
+"""
+This module tracks and manages deployed app versions. We currently use the tools.metadata field
+to store the information detailing modal deployments and when we need to redeploy due to changes.
+Modal Version Manager - Tracks and manages deployed Modal app versions.
+"""
+
+import asyncio
+import time
+from datetime import datetime
+from typing import Any
+
+import modal
+from pydantic import BaseModel, ConfigDict, Field
+
+from letta.log import get_logger
+from letta.schemas.tool import ToolUpdate
+from letta.services.tool_manager import ToolManager
+from letta.services.tool_sandbox.modal_constants import CACHE_TTL_SECONDS, DEFAULT_CONFIG_KEY, MODAL_DEPLOYMENTS_KEY
+
+logger = get_logger(__name__)
+
+
+class DeploymentInfo(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    """Information about a deployed Modal app."""
+
+    app_name: str = Field(..., description="The name of the modal app.")
+    version_hash: str = Field(..., description="The version hash of the modal app.")
+    deployed_at: datetime = Field(..., description="The time the modal app was deployed.")
+    dependencies: set[str] = Field(default_factory=set, description="A set of dependencies.")
+    # app_reference: modal.App | None = Field(None, description="The reference to the modal app.", exclude=True)
+    app_reference: Any = Field(None, description="The reference to the modal app.", exclude=True)
+
+
+class ModalVersionManager:
+    """Manages versions and deployments of Modal apps using tools.metadata."""
+
+    def __init__(self):
+        self.tool_manager = ToolManager()
+        self._deployment_locks: dict[str, asyncio.Lock] = {}
+        self._cache: dict[str, tuple[DeploymentInfo, float]] = {}
+        self._deployments_in_progress: dict[str, asyncio.Event] = {}
+        self._deployments: dict[str, DeploymentInfo] = {}  # Track all deployments for stats
+
+    @staticmethod
+    def _make_cache_key(tool_id: str, sandbox_config_id: str | None = None) -> str:
+        """Generate cache key for tool and config combination."""
+        return f"{tool_id}:{sandbox_config_id or DEFAULT_CONFIG_KEY}"
+
+    @staticmethod
+    def _get_config_key(sandbox_config_id: str | None = None) -> str:
+        """Get standardized config key."""
+        return sandbox_config_id or DEFAULT_CONFIG_KEY
+
+    def _is_cache_valid(self, timestamp: float) -> bool:
+        """Check if cache entry is still valid."""
+        return time.time() - timestamp < CACHE_TTL_SECONDS
+
+    def _get_deployment_metadata(self, tool) -> dict:
+        """Get or initialize modal deployments metadata."""
+        if not tool.metadata_:
+            tool.metadata_ = {}
+        if MODAL_DEPLOYMENTS_KEY not in tool.metadata_:
+            tool.metadata_[MODAL_DEPLOYMENTS_KEY] = {}
+        return tool.metadata_[MODAL_DEPLOYMENTS_KEY]
+
+    def _create_deployment_data(self, app_name: str, version_hash: str, dependencies: set[str]) -> dict:
+        """Create deployment data dictionary for metadata storage."""
+        return {
+            "app_name": app_name,
+            "version_hash": version_hash,
+            "deployed_at": datetime.now().isoformat(),
+            "dependencies": list(dependencies),
+        }
+
+    async def get_deployment(self, tool_id: str, sandbox_config_id: str | None = None, actor=None) -> DeploymentInfo | None:
+        """Get deployment info from tool metadata."""
+        cache_key = self._make_cache_key(tool_id, sandbox_config_id)
+
+        if cache_key in self._cache:
+            info, timestamp = self._cache[cache_key]
+            if self._is_cache_valid(timestamp):
+                return info
+
+        tool = self.tool_manager.get_tool_by_id(tool_id, actor=actor)
+        if not tool or not tool.metadata_:
+            return None
+
+        modal_deployments = tool.metadata_.get(MODAL_DEPLOYMENTS_KEY, {})
+        config_key = self._get_config_key(sandbox_config_id)
+
+        if config_key not in modal_deployments:
+            return None
+
+        deployment_data = modal_deployments[config_key]
+
+        info = DeploymentInfo(
+            app_name=deployment_data["app_name"],
+            version_hash=deployment_data["version_hash"],
+            deployed_at=datetime.fromisoformat(deployment_data["deployed_at"]),
+            dependencies=set(deployment_data.get("dependencies", [])),
+            app_reference=None,
+        )
+
+        self._cache[cache_key] = (info, time.time())
+        return info
+
+    async def register_deployment(
+        self,
+        tool_id: str,
+        app_name: str,
+        version_hash: str,
+        app: modal.App,
+        dependencies: set[str] | None = None,
+        sandbox_config_id: str | None = None,
+        actor=None,
+    ) -> DeploymentInfo:
+        """Register a new deployment in tool metadata."""
+        cache_key = self._make_cache_key(tool_id, sandbox_config_id)
+        config_key = self._get_config_key(sandbox_config_id)
+
+        async with self.get_deployment_lock(cache_key):
+            tool = self.tool_manager.get_tool_by_id(tool_id, actor=actor)
+            if not tool:
+                raise ValueError(f"Tool {tool_id} not found")
+
+            modal_deployments = self._get_deployment_metadata(tool)
+
+            info = DeploymentInfo(
+                app_name=app_name,
+                version_hash=version_hash,
+                deployed_at=datetime.now(),
+                dependencies=dependencies or set(),
+                app_reference=app,
+            )
+
+            modal_deployments[config_key] = self._create_deployment_data(app_name, version_hash, info.dependencies)
+
+            # Use ToolUpdate to update metadata
+            tool_update = ToolUpdate(metadata_=tool.metadata_)
+            await self.tool_manager.update_tool_by_id_async(
+                tool_id=tool_id,
+                tool_update=tool_update,
+                actor=actor,
+            )
+
+            self._cache[cache_key] = (info, time.time())
+            self._deployments[cache_key] = info  # Track for stats
+            return info
+
+    async def needs_redeployment(self, tool_id: str, current_version: str, sandbox_config_id: str | None = None, actor=None) -> bool:
+        """Check if an app needs to be redeployed."""
+        deployment = await self.get_deployment(tool_id, sandbox_config_id, actor=actor)
+        if not deployment:
+            return True
+        return deployment.version_hash != current_version
+
+    def get_deployment_lock(self, cache_key: str) -> asyncio.Lock:
+        """Get or create a deployment lock for a tool+config combination."""
+        if cache_key not in self._deployment_locks:
+            self._deployment_locks[cache_key] = asyncio.Lock()
+        return self._deployment_locks[cache_key]
+
+    def mark_deployment_in_progress(self, cache_key: str, version_hash: str) -> str:
+        """Mark that a deployment is in progress for a specific version.
+
+        Returns a unique deployment ID that should be used to complete/fail the deployment.
+        """
+        deployment_key = f"{cache_key}:{version_hash}"
+        if deployment_key not in self._deployments_in_progress:
+            self._deployments_in_progress[deployment_key] = asyncio.Event()
+        return deployment_key
+
+    def is_deployment_in_progress(self, cache_key: str, version_hash: str) -> bool:
+        """Check if a deployment is currently in progress."""
+        deployment_key = f"{cache_key}:{version_hash}"
+        return deployment_key in self._deployments_in_progress
+
+    async def wait_for_deployment(self, cache_key: str, version_hash: str, timeout: float = 120) -> bool:
+        """Wait for an in-progress deployment to complete.
+
+        Returns True if deployment completed within timeout, False otherwise.
+        """
+        deployment_key = f"{cache_key}:{version_hash}"
+        if deployment_key not in self._deployments_in_progress:
+            return True  # No deployment in progress
+
+        event = self._deployments_in_progress[deployment_key]
+        try:
+            await asyncio.wait_for(event.wait(), timeout=timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
+
+    def complete_deployment(self, deployment_key: str):
+        """Mark a deployment as complete and wake up any waiters."""
+        if deployment_key in self._deployments_in_progress:
+            self._deployments_in_progress[deployment_key].set()
+            # Clean up after a short delay to allow waiters to wake up
+            asyncio.create_task(self._cleanup_deployment_marker(deployment_key))
+
+    async def _cleanup_deployment_marker(self, deployment_key: str):
+        """Clean up deployment marker after a delay."""
+        await asyncio.sleep(5)  # Give waiters time to wake up
+        if deployment_key in self._deployments_in_progress:
+            del self._deployments_in_progress[deployment_key]
+
+    async def force_redeploy(self, tool_id: str, sandbox_config_id: str | None = None, actor=None):
+        """Force a redeployment by removing deployment info from tool metadata."""
+        cache_key = self._make_cache_key(tool_id, sandbox_config_id)
+        config_key = self._get_config_key(sandbox_config_id)
+
+        async with self.get_deployment_lock(cache_key):
+            tool = self.tool_manager.get_tool_by_id(tool_id, actor=actor)
+            if not tool or not tool.metadata_:
+                return
+
+            modal_deployments = tool.metadata_.get(MODAL_DEPLOYMENTS_KEY, {})
+            if config_key in modal_deployments:
+                del modal_deployments[config_key]
+
+                # Use ToolUpdate to update metadata
+                tool_update = ToolUpdate(metadata_=tool.metadata_)
+                await self.tool_manager.update_tool_by_id_async(
+                    tool_id=tool_id,
+                    tool_update=tool_update,
+                    actor=actor,
+                )
+
+                if cache_key in self._cache:
+                    del self._cache[cache_key]
+
+    def clear_deployments(self):
+        """Clear all deployment tracking (for testing purposes)."""
+        self._deployments.clear()
+        self._cache.clear()
+        self._deployments_in_progress.clear()
+
+    async def get_deployment_stats(self) -> dict:
+        """Get statistics about current deployments."""
+        total_deployments = len(self._deployments)
+        active_deployments = len([d for d in self._deployments.values() if d])
+        stale_deployments = total_deployments - active_deployments
+
+        deployments_list = []
+        for cache_key, deployment in self._deployments.items():
+            if deployment:
+                deployments_list.append(
+                    {
+                        "app_name": deployment.app_name,
+                        "version": deployment.version_hash,
+                        "usage_count": 1,  # Track usage in future
+                        "deployed_at": deployment.deployed_at.isoformat(),
+                    }
+                )
+
+        return {
+            "total_deployments": total_deployments,
+            "active_deployments": active_deployments,
+            "stale_deployments": stale_deployments,
+            "deployments": deployments_list,
+        }
+
+
+_version_manager = None
+
+
+def get_version_manager() -> ModalVersionManager:
+    """Get the global Modal version manager instance."""
+    global _version_manager
+    if _version_manager is None:
+        _version_manager = ModalVersionManager()
+    return _version_manager

letta/services/tool_sandbox/safe_pickle.py

@@ -0,0 +1,193 @@
+"""Safe pickle serialization wrapper for Modal sandbox.
+
+This module provides defensive serialization utilities to prevent segmentation
+faults and other crashes when passing complex objects to Modal containers.
+"""
+
+import pickle
+import sys
+from typing import Any, Optional, Tuple
+
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+# Serialization limits
+MAX_PICKLE_SIZE = 10 * 1024 * 1024  # 10MB limit
+MAX_RECURSION_DEPTH = 50  # Prevent deep object graphs
+PICKLE_PROTOCOL = 4  # Use protocol 4 for better compatibility
+
+
+class SafePickleError(Exception):
+    """Raised when safe pickling fails."""
+
+
+class RecursionLimiter:
+    """Context manager to limit recursion depth during pickling."""
+
+    def __init__(self, max_depth: int):
+        self.max_depth = max_depth
+        self.original_limit = None
+
+    def __enter__(self):
+        self.original_limit = sys.getrecursionlimit()
+        sys.setrecursionlimit(min(self.max_depth, self.original_limit))
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.original_limit is not None:
+            sys.setrecursionlimit(self.original_limit)
+
+
+def safe_pickle_dumps(obj: Any, max_size: int = MAX_PICKLE_SIZE) -> bytes:
+    """Safely pickle an object with size and recursion limits.
+
+    Args:
+        obj: The object to pickle
+        max_size: Maximum allowed pickle size in bytes
+
+    Returns:
+        bytes: The pickled object
+
+    Raises:
+        SafePickleError: If pickling fails or exceeds limits
+    """
+    try:
+        # First check for obvious size issues
+        # Do a quick pickle to check size
+        quick_pickle = pickle.dumps(obj, protocol=PICKLE_PROTOCOL)
+        if len(quick_pickle) > max_size:
+            raise SafePickleError(f"Pickle size {len(quick_pickle)} exceeds limit {max_size}")
+
+        # Check recursion depth by traversing the object
+        def check_depth(obj, depth=0):
+            if depth > MAX_RECURSION_DEPTH:
+                raise SafePickleError(f"Object graph too deep (depth > {MAX_RECURSION_DEPTH})")
+
+            if isinstance(obj, (list, tuple)):
+                for item in obj:
+                    check_depth(item, depth + 1)
+            elif isinstance(obj, dict):
+                for value in obj.values():
+                    check_depth(value, depth + 1)
+            elif hasattr(obj, "__dict__"):
+                check_depth(obj.__dict__, depth + 1)
+
+        check_depth(obj)
+
+        logger.debug(f"Successfully pickled object of size {len(quick_pickle)} bytes")
+        return quick_pickle
+
+    except SafePickleError:
+        raise
+    except RecursionError as e:
+        raise SafePickleError(f"Object graph too deep: {e}")
+    except Exception as e:
+        raise SafePickleError(f"Failed to pickle object: {e}")
+
+
+def safe_pickle_loads(data: bytes) -> Any:
+    """Safely unpickle data with error handling.
+
+    Args:
+        data: The pickled data
+
+    Returns:
+        Any: The unpickled object
+
+    Raises:
+        SafePickleError: If unpickling fails
+    """
+    if not data:
+        raise SafePickleError("Cannot unpickle empty data")
+
+    if len(data) > MAX_PICKLE_SIZE:
+        raise SafePickleError(f"Pickle data size {len(data)} exceeds limit {MAX_PICKLE_SIZE}")
+
+    try:
+        obj = pickle.loads(data)
+        logger.debug(f"Successfully unpickled object from {len(data)} bytes")
+        return obj
+    except Exception as e:
+        raise SafePickleError(f"Failed to unpickle data: {e}")
+
+
+def try_pickle_with_fallback(obj: Any, fallback_value: Any = None, max_size: int = MAX_PICKLE_SIZE) -> Tuple[Optional[bytes], bool]:
+    """Try to pickle an object with fallback on failure.
+
+    Args:
+        obj: The object to pickle
+        fallback_value: Value to use if pickling fails
+        max_size: Maximum allowed pickle size
+
+    Returns:
+        Tuple of (pickled_data or None, success_flag)
+    """
+    try:
+        pickled = safe_pickle_dumps(obj, max_size)
+        return pickled, True
+    except SafePickleError as e:
+        logger.warning(f"Failed to pickle object, using fallback: {e}")
+        if fallback_value is not None:
+            try:
+                pickled = safe_pickle_dumps(fallback_value, max_size)
+                return pickled, False
+            except SafePickleError:
+                pass
+    return None, False
+
+
+def validate_pickleable(obj: Any) -> bool:
+    """Check if an object can be safely pickled.
+
+    Args:
+        obj: The object to validate
+
+    Returns:
+        bool: True if the object can be pickled safely
+    """
+    try:
+        # Try to pickle to a small buffer
+        safe_pickle_dumps(obj, max_size=MAX_PICKLE_SIZE)
+        return True
+    except SafePickleError:
+        return False
+
+
+def sanitize_for_pickle(obj: Any) -> Any:
+    """Sanitize an object for safe pickling.
+
+    This function attempts to make an object pickleable by converting
+    problematic types to safe alternatives.
+
+    Args:
+        obj: The object to sanitize
+
+    Returns:
+        Any: A sanitized version of the object
+    """
+    # Handle common problematic types
+    if hasattr(obj, "__dict__"):
+        # For objects with __dict__, try to sanitize attributes
+        sanitized = {}
+        for key, value in obj.__dict__.items():
+            if key.startswith("_"):
+                continue  # Skip private attributes
+
+            # Convert non-pickleable types
+            if callable(value):
+                sanitized[key] = f"<function {value.__name__}>"
+            elif hasattr(value, "__module__"):
+                sanitized[key] = f"<{value.__class__.__name__} object>"
+            else:
+                try:
+                    # Test if the value is pickleable
+                    pickle.dumps(value, protocol=PICKLE_PROTOCOL)
+                    sanitized[key] = value
+                except:
+                    sanitized[key] = str(value)
+
+        return sanitized
+
+    # For other types, return as-is and let pickle handle it
+    return obj

letta/settings.py

@@ -18,7 +18,8 @@ class ToolSettings(BaseSettings):
     e2b_api_key: str | None = Field(default=None, description="API key for using E2B as a tool sandbox")
     e2b_sandbox_template_id: str | None = Field(default=None, description="Template ID for E2B Sandbox. Updated Manually.")
 
-    modal_api_key: str | None = Field(default=None, description="API key for using Modal as a tool sandbox")
+    modal_token_id: str | None = Field(default=None, description="Token id for using Modal as a tool sandbox")
+    modal_token_secret: str | None = Field(default=None, description="Token secret for using Modal as a tool sandbox")
 
     # Search Providers
     tavily_api_key: str | None = Field(default=None, description="API key for using Tavily as a search provider.")
@@ -41,7 +42,7 @@ class ToolSettings(BaseSettings):
     def sandbox_type(self) -> SandboxType:
         if self.e2b_api_key:
             return SandboxType.E2B
-        elif self.modal_api_key:
+        elif self.modal_token_id and self.modal_token_secret:
             return SandboxType.MODAL
         else:
             return SandboxType.LOCAL
@@ -267,6 +268,7 @@ class Settings(BaseSettings):
     # experimental toggle
     use_experimental: bool = False
     use_vertex_structured_outputs_experimental: bool = False
+    use_asyncio_shield: bool = True
 
     # Database pool monitoring
     enable_db_pool_monitoring: bool = True  # Enable connection pool monitoring
@@ -339,7 +341,7 @@ class Settings(BaseSettings):
 class TestSettings(Settings):
     model_config = SettingsConfigDict(env_prefix="letta_test_", extra="ignore")
 
-    letta_dir: Path | None = Field(Path.home() / ".letta/test", env="LETTA_TEST_DIR")
+    letta_dir: Path | None = Field(Path.home() / ".letta/test", alias="LETTA_TEST_DIR")
 
 
 class LogSettings(BaseSettings):

letta/templates/sandbox_code_file.py.j2

@@ -28,15 +28,13 @@ _function_result = {{ invoke_function_call }}
 
 {# Use a temporary Pydantic wrapper to recursively serialize any nested Pydantic objects #}
 try:
-    from pydantic import BaseModel
+    from pydantic import BaseModel, ConfigDict
     from typing import Any
 
     class _TempResultWrapper(BaseModel):
+        model_config = ConfigDict(arbitrary_types_allowed=True)
         result: Any
 
-        class Config:
-            arbitrary_types_allowed = True
-
     _wrapped = _TempResultWrapper(result=_function_result)
     _serialized_result = _wrapped.model_dump()['result']
 except ImportError:

letta/templates/sandbox_code_file_async.py.j2

@@ -30,15 +30,13 @@ async def _async_wrapper():
 
     {# Use a temporary Pydantic wrapper to recursively serialize any nested Pydantic objects #}
     try:
-        from pydantic import BaseModel
+        from pydantic import BaseModel, ConfigDict
         from typing import Any
 
         class _TempResultWrapper(BaseModel):
+            model_config = ConfigDict(arbitrary_types_allowed=True)
             result: Any
 
-            class Config:
-                arbitrary_types_allowed = True
-
         _wrapped = _TempResultWrapper(result=_function_result)
         _serialized_result = _wrapped.model_dump()['result']
     except ImportError:

letta/utils.py

@@ -874,7 +874,7 @@ def validate_function_response(function_response: Any, return_char_limit: int, s
         function_response_string = str(function_response)
 
     # TODO we should change this to a max token limit that's variable based on tokens remaining (or context-window)
-    if truncate and len(function_response_string) > return_char_limit:
+    if truncate and return_char_limit and len(function_response_string) > return_char_limit:
         logger.warning(f"function return was over limit ({len(function_response_string)} > {return_char_limit}) and was truncated")
         function_response_string = f"{function_response_string[:return_char_limit]}... [NOTE: function output was truncated since it exceeded the character limit ({len(function_response_string)} > {return_char_limit})]"
 

{letta_nightly-0.11.3.dev20250819104229.dist-info → letta_nightly-0.11.4.dev20250820213507.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.11.3.dev20250819104229
+Version: 0.11.4.dev20250820213507
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -68,7 +68,7 @@ Requires-Dist: mistralai (>=1.8.1,<2.0.0)
 Requires-Dist: modal (>=1.1.0,<2.0.0) ; extra == "cloud-tool-sandbox"
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=2.1.0,<3.0.0)
-Requires-Dist: openai (>=1.60.0,<2.0.0)
+Requires-Dist: openai (>=1.99.9,<2.0.0)
 Requires-Dist: opentelemetry-api (==1.30.0)
 Requires-Dist: opentelemetry-exporter-otlp (==1.30.0)
 Requires-Dist: opentelemetry-instrumentation-requests (==0.51b0)