letta-nightly 0.8.8.dev20250703104323__py3-none-any.whl → 0.8.9.dev20250703191231__py3-none-any.whl

letta/services/tool_manager.py

@@ -15,7 +15,6 @@ from letta.constants import (
     LETTA_TOOL_MODULE_NAMES,
     LETTA_TOOL_SET,
     MCP_TOOL_TAG_NAME_PREFIX,
-    MULTI_AGENT_TOOLS,
 )
 from letta.functions.functions import derive_openai_json_schema, load_function_set
 from letta.log import get_logger
@@ -29,6 +28,7 @@ from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
+from letta.services.helpers.agent_manager_helper import calculate_multi_agent_tools
 from letta.services.mcp.types import SSEServerConfig, StdioServerConfig
 from letta.utils import enforce_types, printd
 
@@ -419,7 +419,7 @@ class ToolManager:
                 elif name in BASE_MEMORY_TOOLS:
                     tool_type = ToolType.LETTA_MEMORY_CORE
                     tags = [tool_type.value]
-                elif name in MULTI_AGENT_TOOLS:
+                elif name in calculate_multi_agent_tools():
                     tool_type = ToolType.LETTA_MULTI_AGENT_CORE
                     tags = [tool_type.value]
                 elif name in BASE_SLEEPTIME_TOOLS:
@@ -435,9 +435,8 @@ class ToolManager:
                     tool_type = ToolType.LETTA_FILES_CORE
                     tags = [tool_type.value]
                 else:
-                    raise ValueError(
-                        f"Tool name {name} is not in the list of base tool names: {BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_CHAT_TOOLS}"
-                    )
+                    logger.warning(f"Tool name {name} is not in any known base tool set, skipping")
+                    continue
 
                 # create to tool
                 tools.append(
@@ -486,7 +485,7 @@ class ToolManager:
                 tool_type = ToolType.LETTA_MEMORY_CORE
             elif name in BASE_SLEEPTIME_TOOLS:
                 tool_type = ToolType.LETTA_SLEEPTIME_CORE
-            elif name in MULTI_AGENT_TOOLS:
+            elif name in calculate_multi_agent_tools():
                 tool_type = ToolType.LETTA_MULTI_AGENT_CORE
             elif name in BASE_VOICE_SLEEPTIME_TOOLS or name in BASE_VOICE_SLEEPTIME_CHAT_TOOLS:
                 tool_type = ToolType.LETTA_VOICE_SLEEPTIME_CORE
@@ -495,7 +494,8 @@ class ToolManager:
             elif name in FILES_TOOLS:
                 tool_type = ToolType.LETTA_FILES_CORE
             else:
-                raise ValueError(f"Tool name {name} is not recognized in any known base tool set.")
+                logger.warning(f"Tool name {name} is not in any known base tool set, skipping")
+                continue
 
             if allowed_types is not None and tool_type not in allowed_types:
                 continue

letta/settings.py

@@ -6,6 +6,7 @@ from pydantic import AliasChoices, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from letta.local_llm.constants import DEFAULT_WRAPPER_NAME
+from letta.services.summarizer.enums import SummarizationMode
 
 
 class ToolSettings(BaseSettings):
@@ -38,6 +39,13 @@ class ToolSettings(BaseSettings):
 class SummarizerSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="letta_summarizer_", extra="ignore")
 
+    mode: SummarizationMode = SummarizationMode.STATIC_MESSAGE_BUFFER
+    message_buffer_limit: int = 60
+    message_buffer_min: int = 15
+    enable_summarization: bool = True
+    max_summarization_retries: int = 3
+
+    # TODO(cliandy): the below settings are tied to old summarization and should be deprecated or moved
     # Controls if we should evict all messages
     # TODO: Can refactor this into an enum if we have a bunch of different kinds of summarizers
     evict_all_messages: bool = False
@@ -211,8 +219,9 @@ class Settings(BaseSettings):
     otel_preferred_temporality: Optional[int] = Field(
         default=1, ge=0, le=2, description="Exported metric temporality. {0: UNSPECIFIED, 1: DELTA, 2: CUMULATIVE}"
     )
-    disable_tracing: bool = False
-    llm_api_logging: bool = True
+    disable_tracing: bool = Field(default=False, description="Disable OTEL Tracing")
+    llm_api_logging: bool = Field(default=True, description="Enable LLM API logging at each step")
+    track_last_agent_run: bool = Field(default=False, description="Update last agent run metrics")
 
     # uvicorn settings
     uvicorn_workers: int = 1

letta/templates/summary_request_text.j2

@@ -0,0 +1,19 @@
+{% if retain_count == 0 %}
+You’re a memory-recall helper for an AI that is about to forget all prior messages. Scan the conversation history and write crisp notes that capture any important facts or insights about the conversation history.
+{% else %}
+You’re a memory-recall helper for an AI that can only keep the last {{ retain_count }} messages. Scan the conversation history, focusing on messages about to drop out of that window, and write crisp notes that capture any important facts or insights about the human so they aren’t lost.
+{% endif %}
+
+{% if evicted_messages %}
+(Older) Evicted Messages:
+{% for item in evicted_messages %}
+    {{ item }}
+{% endfor %}
+{% endif %}
+
+{% if retain_count > 0 and in_context_messages %}
+(Newer) In-Context Messages:
+{% for item in in_context_messages %}
+    {{ item }}
+{% endfor %}
+{% endif %}

letta/utils.py

@@ -12,11 +12,12 @@ import re
 import subprocess
 import sys
 import uuid
+from collections.abc import Coroutine
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from functools import wraps
 from logging import Logger
-from typing import Any, Coroutine, List, Union, _GenericAlias, get_args, get_origin, get_type_hints
+from typing import Any, Coroutine, Union, _GenericAlias, get_args, get_origin, get_type_hints
 from urllib.parse import urljoin, urlparse
 
 import demjson3 as demjson
@@ -519,7 +520,7 @@ def enforce_types(func):
         arg_names = inspect.getfullargspec(func).args
 
         # Pair each argument with its corresponding type hint
-        args_with_hints = dict(zip(arg_names[1:], args[1:]))  # Skipping 'self'
+        args_with_hints = dict(zip(arg_names[1:], args[1:], strict=False))  # Skipping 'self'
 
         # Function to check if a value matches a given type hint
         def matches_type(value, hint):
@@ -557,7 +558,7 @@ def enforce_types(func):
     return wrapper
 
 
-def annotate_message_json_list_with_tool_calls(messages: List[dict], allow_tool_roles: bool = False):
+def annotate_message_json_list_with_tool_calls(messages: list[dict], allow_tool_roles: bool = False):
     """Add in missing tool_call_id fields to a list of messages using function call style
 
     Walk through the list forwards:
@@ -946,7 +947,7 @@ def get_human_text(name: str, enforce_limit=True):
     for file_path in list_human_files():
         file = os.path.basename(file_path)
         if f"{name}.txt" == file or name == file:
-            human_text = open(file_path, "r", encoding="utf-8").read().strip()
+            human_text = open(file_path, encoding="utf-8").read().strip()
             if enforce_limit and len(human_text) > CORE_MEMORY_HUMAN_CHAR_LIMIT:
                 raise ValueError(f"Contents of {name}.txt is over the character limit ({len(human_text)} > {CORE_MEMORY_HUMAN_CHAR_LIMIT})")
             return human_text
@@ -958,7 +959,7 @@ def get_persona_text(name: str, enforce_limit=True):
     for file_path in list_persona_files():
         file = os.path.basename(file_path)
         if f"{name}.txt" == file or name == file:
-            persona_text = open(file_path, "r", encoding="utf-8").read().strip()
+            persona_text = open(file_path, encoding="utf-8").read().strip()
             if enforce_limit and len(persona_text) > CORE_MEMORY_PERSONA_CHAR_LIMIT:
                 raise ValueError(
                     f"Contents of {name}.txt is over the character limit ({len(persona_text)} > {CORE_MEMORY_PERSONA_CHAR_LIMIT})"
@@ -991,16 +992,17 @@ def create_uuid_from_string(val: str):
     return uuid.UUID(hex=hex_string)
 
 
-def sanitize_filename(filename: str) -> str:
+def sanitize_filename(filename: str, add_uuid_suffix: bool = False) -> str:
     """
     Sanitize the given filename to prevent directory traversal, invalid characters,
     and reserved names while ensuring it fits within the maximum length allowed by the filesystem.
 
     Parameters:
         filename (str): The user-provided filename.
+        add_uuid_suffix (bool): If True, adds a UUID suffix for uniqueness (legacy behavior).
 
     Returns:
-        str: A sanitized filename that is unique and safe for use.
+        str: A sanitized filename.
     """
     # Extract the base filename to avoid directory components
     filename = os.path.basename(filename)
@@ -1015,14 +1017,21 @@ def sanitize_filename(filename: str) -> str:
     if base.startswith("."):
         raise ValueError(f"Invalid filename - derived file name {base} cannot start with '.'")
 
-    # Truncate the base name to fit within the maximum allowed length
-    max_base_length = MAX_FILENAME_LENGTH - len(ext) - 33  # 32 for UUID + 1 for `_`
-    if len(base) > max_base_length:
-        base = base[:max_base_length]
+    if add_uuid_suffix:
+        # Legacy behavior: Truncate the base name to fit within the maximum allowed length
+        max_base_length = MAX_FILENAME_LENGTH - len(ext) - 33  # 32 for UUID + 1 for `_`
+        if len(base) > max_base_length:
+            base = base[:max_base_length]
 
-    # Append a unique UUID suffix for uniqueness
-    unique_suffix = uuid.uuid4().hex[:4]
-    sanitized_filename = f"{base}_{unique_suffix}{ext}"
+        # Append a unique UUID suffix for uniqueness
+        unique_suffix = uuid.uuid4().hex[:4]
+        sanitized_filename = f"{base}_{unique_suffix}{ext}"
+    else:
+        max_base_length = MAX_FILENAME_LENGTH - len(ext)
+        if len(base) > max_base_length:
+            base = base[:max_base_length]
+
+        sanitized_filename = f"{base}{ext}"
 
     # Return the sanitized filename
     return sanitized_filename
@@ -1101,3 +1110,75 @@ def safe_create_task(coro, logger: Logger, label: str = "background task"):
             logger.exception(f"{label} failed with {type(e).__name__}: {e}")
 
     return asyncio.create_task(wrapper())
+
+
+class CancellationSignal:
+    """
+    A signal that can be checked for cancellation during streaming operations.
+
+    This provides a lightweight way to check if an operation should be cancelled
+    without having to pass job managers and other dependencies through every method.
+    """
+
+    def __init__(self, job_manager=None, job_id=None, actor=None):
+
+        from letta.log import get_logger
+        from letta.schemas.user import User
+        from letta.services.job_manager import JobManager
+
+        self.job_manager: JobManager | None = job_manager
+        self.job_id: str | None = job_id
+        self.actor: User | None = actor
+        self._is_cancelled = False
+        self.logger = get_logger(__name__)
+
+    async def is_cancelled(self) -> bool:
+        """
+        Check if the operation has been cancelled.
+
+        Returns:
+            True if cancelled, False otherwise
+        """
+        from letta.schemas.enums import JobStatus
+
+        if self._is_cancelled:
+            return True
+
+        if not self.job_manager or not self.job_id or not self.actor:
+            return False
+
+        try:
+            job = await self.job_manager.get_job_by_id_async(job_id=self.job_id, actor=self.actor)
+            self._is_cancelled = job.status == JobStatus.cancelled
+            return self._is_cancelled
+        except Exception as e:
+            self.logger.warning(f"Failed to check cancellation status for job {self.job_id}: {e}")
+            return False
+
+    def cancel(self):
+        """Mark this signal as cancelled locally (for testing or direct cancellation)."""
+        self._is_cancelled = True
+
+    async def check_and_raise_if_cancelled(self):
+        """
+        Check for cancellation and raise CancelledError if cancelled.
+
+        Raises:
+            asyncio.CancelledError: If the operation has been cancelled
+        """
+        if await self.is_cancelled():
+            self.logger.info(f"Operation cancelled for job {self.job_id}")
+            raise asyncio.CancelledError(f"Job {self.job_id} was cancelled")
+
+
+class NullCancellationSignal(CancellationSignal):
+    """A null cancellation signal that is never cancelled."""
+
+    def __init__(self):
+        super().__init__()
+
+    async def is_cancelled(self) -> bool:
+        return False
+
+    async def check_and_raise_if_cancelled(self):
+        pass

{letta_nightly-0.8.8.dev20250703104323.dist-info → letta_nightly-0.8.9.dev20250703191231.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.8.dev20250703104323
+Version: 0.8.9.dev20250703191231
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -56,7 +56,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.173,<0.2.0)
+Requires-Dist: letta_client (>=0.1.183,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"