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

letta/agents/voice_sleeptime_agent.py

@@ -3,10 +3,11 @@ from typing import AsyncGenerator, List, Optional, Tuple, Union
 from letta.agents.helpers import _create_letta_response, serialize_message_history
 from letta.agents.letta_agent import LettaAgent
 from letta.orm.enums import ToolType
+from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import MessageCreate
 from letta.schemas.tool_rule import ChildToolRule, ContinueToolRule, InitToolRule, TerminalToolRule
@@ -17,7 +18,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
-from letta.tracing import trace_method
+from letta.types import JsonDict
 
 
 class VoiceSleeptimeAgent(LettaAgent):
@@ -58,7 +59,13 @@ class VoiceSleeptimeAgent(LettaAgent):
     def update_message_transcript(self, message_transcripts: List[str]):
         self.message_transcripts = message_transcripts
 
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 20, use_assistant_message: bool = True) -> LettaResponse:
+    async def step(
+        self,
+        input_messages: List[MessageCreate],
+        max_steps: int = 20,
+        use_assistant_message: bool = True,
+        include_return_message_types: Optional[List[MessageType]] = None,
+    ) -> LettaResponse:
         """
         Process the user's input message, allowing the model to call memory-related tools
         until it decides to stop and provide a final response.
@@ -85,13 +92,23 @@ class VoiceSleeptimeAgent(LettaAgent):
         )
 
         return _create_letta_response(
-            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+            new_in_context_messages=new_in_context_messages,
+            use_assistant_message=use_assistant_message,
+            usage=usage,
+            include_return_message_types=include_return_message_types,
         )
 
     @trace_method
-    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState, agent_step_span: Optional["Span"] = None):
+    async def _execute_tool(
+        self,
+        tool_name: str,
+        tool_args: JsonDict,
+        agent_state: AgentState,
+        agent_step_span: Optional["Span"] = None,
+        step_id: str | None = None,
+    ) -> "ToolExecutionResult":
         """
-        Executes a tool and returns (result, success_flag).
+        Executes a tool and returns the ToolExecutionResult
         """
         from letta.schemas.tool_execution_result import ToolExecutionResult
 

letta/constants.py

@@ -21,6 +21,15 @@ LETTA_CORE_TOOL_MODULE_NAME = "letta.functions.function_sets.base"
 LETTA_MULTI_AGENT_TOOL_MODULE_NAME = "letta.functions.function_sets.multi_agent"
 LETTA_VOICE_TOOL_MODULE_NAME = "letta.functions.function_sets.voice"
 LETTA_BUILTIN_TOOL_MODULE_NAME = "letta.functions.function_sets.builtin"
+LETTA_FILES_TOOL_MODULE_NAME = "letta.functions.function_sets.files"
+
+LETTA_TOOL_MODULE_NAMES = [
+    LETTA_CORE_TOOL_MODULE_NAME,
+    LETTA_MULTI_AGENT_TOOL_MODULE_NAME,
+    LETTA_VOICE_TOOL_MODULE_NAME,
+    LETTA_BUILTIN_TOOL_MODULE_NAME,
+    LETTA_FILES_TOOL_MODULE_NAME,
+]
 
 
 # String in the error message for when the context window is too large
@@ -112,6 +121,9 @@ MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
 # Built in tools
 BUILTIN_TOOLS = ["run_code", "web_search"]
 
+# Built in tools
+FILES_TOOLS = ["open_file", "close_file", "grep", "search_files"]
+
 # Set of all built-in Letta tools
 LETTA_TOOL_SET = set(
     BASE_TOOLS
@@ -121,6 +133,7 @@ LETTA_TOOL_SET = set(
     + BASE_VOICE_SLEEPTIME_TOOLS
     + BASE_VOICE_SLEEPTIME_CHAT_TOOLS
     + BUILTIN_TOOLS
+    + FILES_TOOLS
 )
 
 
@@ -294,6 +307,7 @@ CORE_MEMORY_SOURCE_CHAR_LIMIT: int = 5000
 # Function return limits
 FUNCTION_RETURN_CHAR_LIMIT = 6000  # ~300 words
 BASE_FUNCTION_RETURN_CHAR_LIMIT = 1000000  # very high (we rely on implementation)
+FILE_IS_TRUNCATED_WARNING = "# NOTE: This block is truncated, use functions to view the full content."
 
 MAX_PAUSE_HEARTBEATS = 360  # in min
 
@@ -316,3 +330,7 @@ RESERVED_FILENAMES = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "LPT1", "LPT2"
 WEB_SEARCH_CLIP_CONTENT = False
 WEB_SEARCH_INCLUDE_SCORE = False
 WEB_SEARCH_SEPARATOR = "\n" + "-" * 40 + "\n"
+
+REDIS_INCLUDE = "INCLUDE"
+REDIS_EXCLUDE = "EXCLUDE"
+REDIS_SET_DEFAULT_VAL = "None"

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,9 +5,11 @@ 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
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
@@ -21,7 +23,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):
@@ -63,6 +64,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
         run_ids = []
 
@@ -87,7 +89,10 @@ class SleeptimeMultiAgentV2(BaseAgent):
         )
         # Perform foreground agent step
         response = await foreground_agent.step(
-            input_messages=new_messages, max_steps=max_steps, use_assistant_message=use_assistant_message
+            input_messages=new_messages,
+            max_steps=max_steps,
+            use_assistant_message=use_assistant_message,
+            include_return_message_types=include_return_message_types,
         )
 
         # Get last response messages
@@ -129,8 +134,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ):
-        response = await self.step(input_messages, max_steps, use_assistant_message)
+        response = await self.step(
+            input_messages, max_steps, use_assistant_message, request_start_timestamp_ns, include_return_message_types
+        )
 
         for message in response.messages:
             yield f"data: {message.model_dump_json()}\n\n"
@@ -144,6 +152,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> AsyncGenerator[str, None]:
         # Prepare new messages
         new_messages = []
@@ -170,6 +179,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             max_steps=max_steps,
             use_assistant_message=use_assistant_message,
             request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=include_return_message_types,
         ):
             yield chunk
 

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