letta-nightly 0.8.0.dev20250606104326__py3-none-any.whl → 0.8.2.dev20250606215616__py3-none-any.whl

letta/data_sources/redis_client.py

@@ -0,0 +1,282 @@
+import asyncio
+from functools import wraps
+from typing import Any, Optional, Set, Union
+
+import redis.asyncio as redis
+from redis import RedisError
+
+from letta.constants import REDIS_EXCLUDE, REDIS_INCLUDE, REDIS_SET_DEFAULT_VAL
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+_client_instance = None
+
+
+class AsyncRedisClient:
+    """Async Redis client with connection pooling and error handling"""
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 6379,
+        db: int = 0,
+        password: Optional[str] = None,
+        max_connections: int = 50,
+        decode_responses: bool = True,
+        socket_timeout: int = 5,
+        socket_connect_timeout: int = 5,
+        retry_on_timeout: bool = True,
+        health_check_interval: int = 30,
+    ):
+        """
+        Initialize Redis client with connection pool.
+
+        Args:
+            host: Redis server hostname
+            port: Redis server port
+            db: Database number
+            password: Redis password if required
+            max_connections: Maximum number of connections in pool
+            decode_responses: Decode byte responses to strings
+            socket_timeout: Socket timeout in seconds
+            socket_connect_timeout: Socket connection timeout
+            retry_on_timeout: Retry operations on timeout
+            health_check_interval: Seconds between health checks
+        """
+        self.pool = redis.ConnectionPool(
+            host=host,
+            port=port,
+            db=db,
+            password=password,
+            max_connections=max_connections,
+            decode_responses=decode_responses,
+            socket_timeout=socket_timeout,
+            socket_connect_timeout=socket_connect_timeout,
+            retry_on_timeout=retry_on_timeout,
+            health_check_interval=health_check_interval,
+        )
+        self._client = None
+        self._lock = asyncio.Lock()
+
+    async def get_client(self) -> redis.Redis:
+        """Get or create Redis client instance."""
+        if self._client is None:
+            async with self._lock:
+                if self._client is None:
+                    self._client = redis.Redis(connection_pool=self.pool)
+        return self._client
+
+    async def close(self):
+        """Close Redis connection and cleanup."""
+        if self._client:
+            await self._client.close()
+            await self.pool.disconnect()
+            self._client = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.get_client()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+    # Health check and connection management
+    async def ping(self) -> bool:
+        """Check if Redis is accessible."""
+        try:
+            client = await self.get_client()
+            await client.ping()
+            return True
+        except RedisError:
+            logger.exception("Redis ping failed")
+            return False
+
+    async def wait_for_ready(self, timeout: int = 30, interval: float = 0.5):
+        """Wait for Redis to be ready."""
+        start_time = asyncio.get_event_loop().time()
+        while (asyncio.get_event_loop().time() - start_time) < timeout:
+            if await self.ping():
+                return
+            await asyncio.sleep(interval)
+        raise ConnectionError(f"Redis not ready after {timeout} seconds")
+
+    # Retry decorator for resilience
+    def with_retry(max_attempts: int = 3, delay: float = 0.1):
+        """Decorator to retry Redis operations on failure."""
+
+        def decorator(func):
+            @wraps(func)
+            async def wrapper(self, *args, **kwargs):
+                last_error = None
+                for attempt in range(max_attempts):
+                    try:
+                        return await func(self, *args, **kwargs)
+                    except (ConnectionError, TimeoutError) as e:
+                        last_error = e
+                        if attempt < max_attempts - 1:
+                            await asyncio.sleep(delay * (2**attempt))
+                        logger.warning(f"Retry {attempt + 1}/{max_attempts} for {func.__name__}: {e}")
+                raise last_error
+
+            return wrapper
+
+        return decorator
+
+    # Basic operations with error handling
+    @with_retry()
+    async def get(self, key: str, default: Any = None) -> Any:
+        """Get value by key."""
+        try:
+            client = await self.get_client()
+            return await client.get(key)
+        except:
+            return default
+
+    @with_retry()
+    async def set(
+        self,
+        key: str,
+        value: Union[str, int, float],
+        ex: Optional[int] = None,
+        px: Optional[int] = None,
+        nx: bool = False,
+        xx: bool = False,
+    ) -> bool:
+        """
+        Set key-value with options.
+
+        Args:
+            key: Redis key
+            value: Value to store
+            ex: Expire time in seconds
+            px: Expire time in milliseconds
+            nx: Only set if key doesn't exist
+            xx: Only set if key exists
+        """
+        client = await self.get_client()
+        return await client.set(key, value, ex=ex, px=px, nx=nx, xx=xx)
+
+    @with_retry()
+    async def delete(self, *keys: str) -> int:
+        """Delete one or more keys."""
+        client = await self.get_client()
+        return await client.delete(*keys)
+
+    @with_retry()
+    async def exists(self, *keys: str) -> int:
+        """Check if keys exist."""
+        client = await self.get_client()
+        return await client.exists(*keys)
+
+    # Set operations
+    async def sadd(self, key: str, *members: Union[str, int, float]) -> int:
+        """Add members to set."""
+        client = await self.get_client()
+        return await client.sadd(key, *members)
+
+    async def smembers(self, key: str) -> Set[str]:
+        """Get all set members."""
+        client = await self.get_client()
+        return await client.smembers(key)
+
+    @with_retry()
+    async def smismember(self, key: str, values: list[Any] | Any) -> list[int] | int:
+        """clever!: set member is member"""
+        try:
+            client = await self.get_client()
+            result = await client.smismember(key, values)
+            return result if isinstance(values, list) else result[0]
+        except:
+            return [0] * len(values) if isinstance(values, list) else 0
+
+    async def srem(self, key: str, *members: Union[str, int, float]) -> int:
+        """Remove members from set."""
+        client = await self.get_client()
+        return await client.srem(key, *members)
+
+    async def scard(self, key: str) -> int:
+        client = await self.get_client()
+        return await client.scard(key)
+
+    # Atomic operations
+    async def incr(self, key: str) -> int:
+        """Increment key value."""
+        client = await self.get_client()
+        return await client.incr(key)
+
+    async def decr(self, key: str) -> int:
+        """Decrement key value."""
+        client = await self.get_client()
+        return await client.decr(key)
+
+    async def check_inclusion_and_exclusion(self, member: str, group: str) -> bool:
+        exclude_key = f"{group}_{REDIS_EXCLUDE}"
+        include_key = f"{group}_{REDIS_INCLUDE}"
+        # 1. if the member IS excluded from the group
+        if self.exists(exclude_key) and await self.scard(exclude_key) > 1:
+            return bool(await self.smismember(exclude_key, member))
+        # 2. if the group HAS an include set, is the member in that set?
+        if self.exists(include_key) and await self.scard(include_key) > 1:
+            return bool(await self.smismember(include_key, member))
+        # 3. if the group does NOT HAVE an include set and member NOT excluded
+        return True
+
+    async def create_inclusion_exclusion_keys(self, group: str) -> None:
+        redis_client = await self.get_client()
+        await redis_client.sadd(self._get_group_inclusion_key(group), REDIS_SET_DEFAULT_VAL)
+        await redis_client.sadd(self._get_group_exclusion_key(group), REDIS_SET_DEFAULT_VAL)
+
+    @staticmethod
+    def _get_group_inclusion_key(group: str) -> str:
+        return f"{group}_{REDIS_INCLUDE}"
+
+    @staticmethod
+    def _get_group_exclusion_key(group: str) -> str:
+        return f"{group}_{REDIS_EXCLUDE}"
+
+
+class NoopAsyncRedisClient(AsyncRedisClient):
+    async def get(self, key: str, default: Any = None) -> Any:
+        return default
+
+    async def exists(self, *keys: str) -> int:
+        return 0
+
+    async def sadd(self, key: str, *members: Union[str, int, float]) -> int:
+        return 0
+
+    async def smismember(self, key: str, values: list[Any] | Any) -> list[int] | int:
+        return [0] * len(values) if isinstance(values, list) else 0
+
+    async def delete(self, *keys: str) -> int:
+        return 0
+
+    async def check_inclusion_and_exclusion(self, member: str, group: str) -> bool:
+        return False
+
+    async def create_inclusion_exclusion_keys(self, group: str) -> None:
+        return None
+
+    async def scard(self, key: str) -> int:
+        return 0
+
+
+async def get_redis_client() -> AsyncRedisClient:
+    global _client_instance
+    if _client_instance is None:
+        try:
+            from letta.settings import settings
+
+            _client_instance = AsyncRedisClient(
+                host=settings.redis_host or "localhost",
+                port=settings.redis_port or 6379,
+            )
+            await _client_instance.wait_for_ready(timeout=5)
+            logger.info("Redis client initialized")
+        except Exception as e:
+            logger.warning(f"Failed to initialize Redis: {e}")
+            _client_instance = NoopAsyncRedisClient()
+    return _client_instance

letta/errors.py

@@ -88,10 +88,6 @@ class LLMPermissionDeniedError(LLMError):
     """Error when permission is denied by LLM service"""
 
 
-class LLMContextWindowExceededError(LLMError):
-    """Error when the context length is exceeded."""
-
-
 class LLMNotFoundError(LLMError):
     """Error when requested resource is not found"""
 

letta/functions/function_sets/files.py

@@ -0,0 +1,58 @@
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+if TYPE_CHECKING:
+    from letta.schemas.agent import AgentState
+    from letta.schemas.file import FileMetadata
+
+
+async def open_file(agent_state: "AgentState", file_name: str, view_range: Optional[Tuple[int, int]]) -> str:
+    """
+    Open up a file in core memory.
+
+    Args:
+        file_name (str): Name of the file to view.
+        view_range (Optional[Tuple[int, int]]): Optional tuple indicating range to view.
+
+    Returns:
+        str: A status message
+    """
+    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
+
+
+async def close_file(agent_state: "AgentState", file_name: str) -> str:
+    """
+    Close a file in core memory.
+
+    Args:
+        file_name (str): Name of the file to close.
+
+    Returns:
+        str: A status message
+    """
+    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
+
+
+async def grep(agent_state: "AgentState", pattern: str) -> str:
+    """
+    Grep tool to search files across data sources with keywords.
+
+    Args:
+        pattern (str): Keyword or regex pattern to search.
+
+    Returns:
+        str: Matching lines or summary output.
+    """
+    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
+
+
+async def search_files(agent_state: "AgentState", query: str) -> List["FileMetadata"]:
+    """
+    Get list of most relevant files across all data sources.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        List[FileMetadata]: List of matching files.
+    """
+    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")

letta/functions/schema_generator.py

@@ -1,6 +1,6 @@
 import inspect
 import warnings
-from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
+from typing import Any, Dict, List, Optional, Tuple, Type, Union, get_args, get_origin
 
 from composio.client.collections import ActionParametersModel
 from docstring_parser import parse
@@ -76,6 +76,23 @@ def type_to_json_schema_type(py_type) -> dict:
     if get_origin(py_type) is Literal:
         return {"type": "string", "enum": get_args(py_type)}
 
+    # Handle tuple types (specifically fixed-length like Tuple[int, int])
+    if origin in (tuple, Tuple):
+        args = get_args(py_type)
+        if len(args) == 0:
+            raise ValueError("Tuple type must have at least one element")
+
+        # Support only fixed-length tuples like Tuple[int, int], not variable-length like Tuple[int, ...]
+        if len(args) == 2 and args[1] is Ellipsis:
+            raise NotImplementedError("Variable-length tuples (e.g., Tuple[int, ...]) are not supported")
+
+        return {
+            "type": "array",
+            "prefixItems": [type_to_json_schema_type(arg) for arg in args],
+            "minItems": len(args),
+            "maxItems": len(args),
+        }
+
     # Handle object types
     if py_type == dict or origin in (dict, Dict):
         args = get_args(py_type)

letta/groups/sleeptime_multi_agent_v2.py

@@ -5,6 +5,7 @@ from typing import AsyncGenerator, List, Optional
 from letta.agents.base_agent import BaseAgent
 from letta.agents.letta_agent import LettaAgent
 from letta.groups.helpers import stringify_message
+from letta.otel.tracing import trace_method
 from letta.schemas.enums import JobStatus
 from letta.schemas.group import Group, ManagerType
 from letta.schemas.job import JobUpdate
@@ -21,7 +22,6 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.step_manager import NoopStepManager, StepManager
 from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
-from letta.tracing import trace_method
 
 
 class SleeptimeMultiAgentV2(BaseAgent):

letta/helpers/datetime_helpers.py

@@ -1,7 +1,9 @@
 import re
 import time
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
+from datetime import timezone as dt_timezone
 from time import strftime
+from typing import Callable
 
 import pytz
 
@@ -66,7 +68,7 @@ def get_local_time(timezone=None):
 def get_utc_time() -> datetime:
     """Get the current UTC time"""
     # return datetime.now(pytz.utc)
-    return datetime.now(timezone.utc)
+    return datetime.now(dt_timezone.utc)
 
 
 def get_utc_time_int() -> int:
@@ -78,9 +80,13 @@ def get_utc_timestamp_ns() -> int:
     return int(time.time_ns())
 
 
+def ns_to_ms(ns: int) -> int:
+    return ns // 1_000_000
+
+
 def timestamp_to_datetime(timestamp_seconds: int) -> datetime:
     """Convert Unix timestamp in seconds to UTC datetime object"""
-    return datetime.fromtimestamp(timestamp_seconds, tz=timezone.utc)
+    return datetime.fromtimestamp(timestamp_seconds, tz=dt_timezone.utc)
 
 
 def format_datetime(dt):
@@ -105,3 +111,41 @@ def extract_date_from_timestamp(timestamp):
 
 def is_utc_datetime(dt: datetime) -> bool:
     return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) == timedelta(0)
+
+
+class AsyncTimer:
+    """An async context manager for timing async code execution.
+
+    Takes in an optional callback_func to call on exit with arguments
+    taking in the elapsed_ms and exc if present.
+
+    Do not use the start and end times outside of this function as they are relative.
+    """
+
+    def __init__(self, callback_func: Callable | None = None):
+        self._start_time_ns = None
+        self._end_time_ns = None
+        self.elapsed_ns = None
+        self.callback_func = callback_func
+
+    async def __aenter__(self):
+        self._start_time_ns = time.perf_counter_ns()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        self._end_time_ns = time.perf_counter_ns()
+        self.elapsed_ns = self._end_time_ns - self._start_time_ns
+        if self.callback_func:
+            from asyncio import iscoroutinefunction
+
+            if iscoroutinefunction(self.callback_func):
+                await self.callback_func(self.elapsed_ms, exc)
+            else:
+                self.callback_func(self.elapsed_ms, exc)
+        return False
+
+    @property
+    def elapsed_ms(self):
+        if self.elapsed_ns is not None:
+            return ns_to_ms(self.elapsed_ns)
+        return None

letta/helpers/decorators.py

@@ -0,0 +1,69 @@
+import inspect
+from functools import wraps
+from typing import Callable
+
+from letta.log import get_logger
+from letta.plugins.plugins import get_experimental_checker
+from letta.settings import settings
+
+logger = get_logger(__name__)
+
+
+def experimental(feature_name: str, fallback_function: Callable, **kwargs):
+    """Decorator that runs a fallback function if experimental feature is not enabled.
+
+    - kwargs from the decorator will be combined with function kwargs and overwritten only for experimental evaluation.
+    - if the decorated function, fallback_function, or experimental checker function is async, the whole call will be async
+    """
+
+    def decorator(f):
+        experimental_checker = get_experimental_checker()
+        is_f_async = inspect.iscoroutinefunction(f)
+        is_fallback_async = inspect.iscoroutinefunction(fallback_function)
+        is_experimental_checker_async = inspect.iscoroutinefunction(experimental_checker)
+
+        async def call_function(func, is_async, *args, **_kwargs):
+            if is_async:
+                return await func(*args, **_kwargs)
+            return func(*args, **_kwargs)
+
+        # asynchronous wrapper if any function is async
+        if any((is_f_async, is_fallback_async, is_experimental_checker_async)):
+
+            @wraps(f)
+            async def async_wrapper(*args, **_kwargs):
+                result = await call_function(experimental_checker, is_experimental_checker_async, feature_name, **dict(_kwargs, **kwargs))
+                if result:
+                    return await call_function(f, is_f_async, *args, **_kwargs)
+                else:
+                    return await call_function(fallback_function, is_fallback_async, *args, **_kwargs)
+
+            return async_wrapper
+
+        else:
+
+            @wraps(f)
+            def wrapper(*args, **_kwargs):
+                if experimental_checker(feature_name, **dict(_kwargs, **kwargs)):
+                    return f(*args, **_kwargs)
+                else:
+                    return fallback_function(*args, **kwargs)
+
+            return wrapper
+
+    return decorator
+
+
+def deprecated(message: str):
+    """Simple decorator that marks a method as deprecated."""
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            if settings.debug:
+                logger.warning(f"Function {f.__name__} is deprecated: {message}.")
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

letta/{services/helpers/noop_helper.py → helpers/singleton.py}

@@ -1,7 +1,12 @@
+# TODO (cliandy): consolidate with decorators later
+from functools import wraps
+
+
 def singleton(cls):
     """Decorator to make a class a Singleton class."""
     instances = {}
 
+    @wraps(cls)
     def get_instance(*args, **kwargs):
         if cls not in instances:
             instances[cls] = cls(*args, **kwargs)