letta-nightly 0.8.6.dev20250627220317__py3-none-any.whl → 0.8.7.dev20250627220731__py3-none-any.whl

letta/__init__.py

@@ -1,6 +1,7 @@
 import os
 
-__version__ = "0.8.5"
+__version__ = "0.8.7"
+
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/constants.py

@@ -83,6 +83,7 @@ SEND_MESSAGE_TOOL_NAME = "send_message"
 # Base tools that cannot be edited, as they access agent state directly
 # Note that we don't include "conversation_search_date" for now
 BASE_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_insert", "archival_memory_search"]
+DEPRECATED_BASE_TOOLS = ["archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 # New v2 collection of the base memory tools (effecitvely same as sleeptime set), to pair with memgpt_v2 prompt
@@ -129,7 +130,7 @@ MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
 BUILTIN_TOOLS = ["run_code", "web_search"]
 
 # Built in tools
-FILES_TOOLS = ["open_file", "close_file", "grep", "search_files"]
+FILES_TOOLS = ["open_files", "grep_files", "search_files"]
 
 FILE_MEMORY_EXISTS_MESSAGE = "The following files are currently accessible in memory:"
 FILE_MEMORY_EMPTY_MESSAGE = (

letta/functions/function_sets/files.py

@@ -1,30 +1,32 @@
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, List, Optional
+
+from letta.functions.types import FileOpenRequest
 
 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 the file with name `file_name` and load the contents into files section in core memory.
+async def open_files(agent_state: "AgentState", file_requests: List[FileOpenRequest], close_all_others: bool = False) -> str:
+    """Open one or more files and load their contents into files section in core memory. Maximum of 5 files can be opened simultaneously.
 
-    Args:
-        file_name (str): Name of the file to view. Required.
-        view_range (Optional[Tuple[int, int]]): Optional tuple indicating range to view.
+    Examples:
+        Open single file (entire content):
+            file_requests = [FileOpenRequest(file_name="config.py")]
 
-    Returns:
-        str: A status message
-    """
-    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
+        Open multiple files with different view ranges:
+            file_requests = [
+                FileOpenRequest(file_name="config.py", offset=1, length=50),     # Lines 1-50
+                FileOpenRequest(file_name="main.py", offset=100, length=100),    # Lines 100-199
+                FileOpenRequest(file_name="utils.py")                            # Entire file
+            ]
 
-
-async def close_file(agent_state: "AgentState", file_name: str) -> str:
-    """
-    Close file with name `file_name` in files section in core memory.
+        Close all other files and open new ones:
+            open_files(agent_state, file_requests, close_all_others=True)
 
     Args:
-        file_name (str): Name of the file to close.
+        file_requests (List[FileOpenRequest]): List of file open requests, each specifying file name and optional view range.
+        close_all_others (bool): If True, closes all other currently open files first. Defaults to False.
 
     Returns:
         str: A status message
@@ -32,7 +34,7 @@ async def close_file(agent_state: "AgentState", file_name: str) -> str:
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 
 
-async def grep(
+async def grep_files(
     agent_state: "AgentState",
     pattern: str,
     include: Optional[str] = None,
@@ -45,7 +47,7 @@ async def grep(
         pattern (str): Keyword or regex pattern to search within file contents.
         include (Optional[str]): Optional keyword or regex pattern to filter filenames to include in the search.
         context_lines (Optional[int]): Number of lines of context to show before and after each match.
-                                       Equivalent to `-C` in grep. Defaults to 3.
+                                       Equivalent to `-C` in grep_files. Defaults to 3.
 
     Returns:
         str: Matching lines with optional surrounding context or a summary output.

letta/functions/schema_generator.py

@@ -9,6 +9,56 @@ from typing_extensions import Literal
 
 from letta.constants import REQUEST_HEARTBEAT_DESCRIPTION, REQUEST_HEARTBEAT_PARAM
 from letta.functions.mcp_client.types import MCPTool
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+def validate_google_style_docstring(function):
+    """Validate that a function's docstring follows Google Python style format.
+
+    Args:
+        function: The function to validate
+
+    Raises:
+        ValueError: If the docstring is not in Google Python style format
+    """
+    if not function.__doc__:
+        raise ValueError(
+            f"Function '{function.__name__}' has no docstring. Expected Google Python style docstring with Args and Returns sections."
+        )
+
+    docstring = function.__doc__.strip()
+
+    # Basic Google style requirements:
+    # 1. Should have Args: section if function has parameters (excluding self, agent_state)
+    # 2. Should have Returns: section if function returns something other than None
+    # 3. Args and Returns sections should be properly formatted
+
+    sig = inspect.signature(function)
+    has_params = any(param.name not in ["self", "agent_state"] for param in sig.parameters.values())
+
+    # Check for Args section if function has parameters
+    if has_params and "Args:" not in docstring:
+        raise ValueError(f"Function '{function.__name__}' with parameters must have 'Args:' section in Google Python style docstring")
+
+    # NOTE: No check for Returns section - this is irrelevant to the LLM
+    # In proper Google Python format, the Returns: is required
+
+    # Validate Args section format if present
+    if "Args:" in docstring:
+        args_start = docstring.find("Args:")
+        args_end = docstring.find("Returns:", args_start) if "Returns:" in docstring[args_start:] else len(docstring)
+        args_section = docstring[args_start:args_end].strip()
+
+        # Check that each parameter is documented
+        for param in sig.parameters.values():
+            if param.name in ["self", "agent_state"]:
+                continue
+            if f"{param.name} (" not in args_section and f"{param.name}:" not in args_section:
+                raise ValueError(
+                    f"Function '{function.__name__}' parameter '{param.name}' not documented in Args section of Google Python style docstring"
+                )
 
 
 def is_optional(annotation):
@@ -277,6 +327,20 @@ def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
                 "description": prop["description"],
             }
 
+        # Handle the case where the property uses anyOf (e.g., Optional types)
+        if "anyOf" in prop:
+            # For Optional types, extract the non-null type
+            non_null_types = [t for t in prop["anyOf"] if t.get("type") != "null"]
+            if len(non_null_types) == 1:
+                # Simple Optional[T] case - use the non-null type
+                return {
+                    "type": non_null_types[0]["type"],
+                    "description": prop["description"],
+                }
+            else:
+                # Complex anyOf case - not supported yet
+                raise ValueError(f"Complex anyOf patterns are not supported: {prop}")
+
         # If it's a regular property with a direct type (e.g., string, number)
         return {
             "type": "string" if prop["type"] == "string" else prop["type"],
@@ -344,7 +408,18 @@ def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
     return clean_schema(schema_part=schema, full_schema=schema)
 
 
-def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None) -> dict:
+def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None, tool_id: Optional[str] = None) -> dict:
+    # Validate that the function has a Google Python style docstring
+    try:
+        validate_google_style_docstring(function)
+    except ValueError:
+        logger.warning(
+            f"Function `{function.__name__}` in module `{function.__module__}` "
+            f"{'(tool_id=' + tool_id + ') ' if tool_id else ''}"
+            f"is not in Google style docstring format. "
+            f"Docstring received:\n{repr(function.__doc__[:200]) if function.__doc__ else 'None'}"
+        )
+
     # Get the signature of the function
     sig = inspect.signature(function)
 
@@ -353,10 +428,19 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
 
     if not description:
         # Support multiline docstrings for complex functions, TODO (cliandy): consider having this as a setting
-        if docstring.long_description:
+        # Always prefer combining short + long description when both exist
+        if docstring.short_description and docstring.long_description:
+            description = f"{docstring.short_description}\n\n{docstring.long_description}"
+        elif docstring.short_description:
+            description = docstring.short_description
+        elif docstring.long_description:
             description = docstring.long_description
         else:
-            description = docstring.short_description
+            description = "No description available"
+
+        examples_section = extract_examples_section(function.__doc__)
+        if examples_section and "Examples:" not in description:
+            description = f"{description}\n\n{examples_section}"
 
     # Prepare the schema dictionary
     schema = {
@@ -443,6 +527,38 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     return schema
 
 
+def extract_examples_section(docstring: Optional[str]) -> Optional[str]:
+    """Extracts the 'Examples:' section from a Google-style docstring.
+
+    Args:
+        docstring (Optional[str]): The full docstring of a function.
+
+    Returns:
+        Optional[str]: The extracted examples section, or None if not found.
+    """
+    if not docstring or "Examples:" not in docstring:
+        return None
+
+    lines = docstring.strip().splitlines()
+    in_examples = False
+    examples_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+
+        if not in_examples and stripped.startswith("Examples:"):
+            in_examples = True
+            examples_lines.append(line)
+            continue
+
+        if in_examples:
+            if stripped and not line.startswith(" ") and stripped.endswith(":"):
+                break
+            examples_lines.append(line)
+
+    return "\n".join(examples_lines).strip() if examples_lines else None
+
+
 def generate_schema_from_args_schema_v2(
     args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:

letta/functions/types.py

@@ -1,6 +1,18 @@
+from typing import Optional
+
 from pydantic import BaseModel, Field
 
 
 class SearchTask(BaseModel):
     query: str = Field(description="Search query for web search")
     question: str = Field(description="Question to answer from search results, considering full conversation context")
+
+
+class FileOpenRequest(BaseModel):
+    file_name: str = Field(description="Name of the file to open")
+    offset: Optional[int] = Field(
+        default=None, description="Optional starting line number (1-indexed). If not specified, starts from beginning of file."
+    )
+    length: Optional[int] = Field(
+        default=None, description="Optional number of lines to view from offset. If not specified, views to end of file."
+    )

letta/groups/sleeptime_multi_agent_v2.py

@@ -141,7 +141,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
         include_return_message_types: Optional[List[MessageType]] = None,
     ):
         response = await self.step(
-            input_messages, max_steps, use_assistant_message, request_start_timestamp_ns, include_return_message_types
+            input_messages=input_messages,
+            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,
         )
 
         for message in response.messages:

letta/orm/sqlalchemy_base.py

@@ -183,6 +183,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier_keys: Optional[List[str]] = None,
         identity_id: Optional[str] = None,
         query_options: Sequence[ORMOption] | None = None,  # ← new
+        has_feedback: Optional[bool] = None,
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
@@ -281,6 +282,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier_keys: Optional[List[str]] = None,
         identity_id: Optional[str] = None,
         check_is_deleted: bool = False,
+        has_feedback: Optional[bool] = None,
         **kwargs,
     ):
         """
@@ -337,6 +339,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         if end_date:
             query = query.filter(cls.created_at < end_date)
 
+        # Feedback filtering
+        if has_feedback is not None and hasattr(cls, "feedback"):
+            if has_feedback:
+                query = query.filter(cls.feedback.isnot(None))
+            else:
+                query = query.filter(cls.feedback.is_(None))
+
         # Handle pagination based on before/after
         if before_obj or after_obj:
             conditions = []

letta/schemas/agent.py

@@ -152,9 +152,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     initial_message_sequence: Optional[List[MessageCreate]] = Field(
         None, description="The initial set of messages to put in the agent's in-context memory."
     )
-    include_base_tools: bool = Field(
-        True, description="If true, attaches the Letta core tools (e.g. archival_memory and core_memory related functions)."
-    )
+    include_base_tools: bool = Field(True, description="If true, attaches the Letta core tools (e.g. core_memory related functions).")
     include_multi_agent_tools: bool = Field(
         False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
     )

letta/server/rest_api/routers/v1/steps.py

@@ -7,6 +7,7 @@ from letta.orm.errors import NoResultFound
 from letta.schemas.step import Step
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.services.step_manager import FeedbackType
 
 router = APIRouter(prefix="/steps", tags=["steps"])
 
@@ -23,6 +24,7 @@ async def list_steps(
     agent_id: Optional[str] = Query(None, description="Filter by the ID of the agent that performed the step"),
     trace_ids: Optional[list[str]] = Query(None, description="Filter by trace ids returned by the server"),
     feedback: Optional[Literal["positive", "negative"]] = Query(None, description="Filter by feedback"),
+    has_feedback: Optional[bool] = Query(None, description="Filter by whether steps have feedback (true) or not (false)"),
     tags: Optional[list[str]] = Query(None, description="Filter by tags"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -49,6 +51,7 @@ async def list_steps(
         agent_id=agent_id,
         trace_ids=trace_ids,
         feedback=feedback,
+        has_feedback=has_feedback,
         tags=tags,
     )
 
@@ -72,7 +75,7 @@ async def retrieve_step(
 @router.patch("/{step_id}/feedback", response_model=Step, operation_id="add_feedback")
 async def add_feedback(
     step_id: str,
-    feedback: Optional[Literal["positive", "negative"]],
+    feedback: Optional[FeedbackType],
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: SyncServer = Depends(get_letta_server),
 ):

letta/server/server.py

@@ -1496,7 +1496,7 @@ class SyncServer(Server):
             await self.agent_manager.attach_block_async(agent_id=main_agent.id, block_id=block.id, actor=actor)
 
         if clear_history and block.value != "":
-            block = await self.block_manager.update_block_async(block_id=block.id, block=BlockUpdate(value=""))
+            block = await self.block_manager.update_block_async(block_id=block.id, block_update=BlockUpdate(value=""), actor=actor)
 
         request = CreateAgent(
             name=main_agent.name + "-doc-sleeptime",

letta/services/agent_manager.py

@@ -16,6 +16,7 @@ from letta.constants import (
     BASE_VOICE_SLEEPTIME_CHAT_TOOLS,
     BASE_VOICE_SLEEPTIME_TOOLS,
     DEFAULT_TIMEZONE,
+    DEPRECATED_BASE_TOOLS,
     FILES_TOOLS,
     MULTI_AGENT_TOOLS,
 )
@@ -77,6 +78,7 @@ from letta.services.helpers.agent_manager_helper import (
     build_agent_passage_query,
     build_passage_query,
     build_source_passage_query,
+    calculate_base_tools,
     check_supports_structured_output,
     compile_system_message,
     derive_system_message,
@@ -261,13 +263,13 @@ class AgentManager:
             elif agent_create.enable_sleeptime:
                 tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
             elif agent_create.agent_type == AgentType.memgpt_v2_agent:
-                tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS_V2)
+                tool_names |= calculate_base_tools(is_v2=True)
             elif agent_create.agent_type == AgentType.react_agent:
                 pass  # no default tools
             elif agent_create.agent_type == AgentType.workflow_agent:
                 pass  # no default tools
             else:
-                tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS)
+                tool_names |= calculate_base_tools(is_v2=False)
         if agent_create.include_multi_agent_tools:
             tool_names |= set(MULTI_AGENT_TOOLS)
 
@@ -428,16 +430,19 @@ class AgentManager:
             elif agent_create.enable_sleeptime:
                 tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
             elif agent_create.agent_type == AgentType.memgpt_v2_agent:
-                tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS_V2)
+                tool_names |= calculate_base_tools(is_v2=True)
             elif agent_create.agent_type == AgentType.react_agent:
                 pass  # no default tools
             elif agent_create.agent_type == AgentType.workflow_agent:
                 pass  # no default tools
             else:
-                tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS)
+                tool_names |= calculate_base_tools(is_v2=False)
         if agent_create.include_multi_agent_tools:
             tool_names |= set(MULTI_AGENT_TOOLS)
 
+        # take out the deprecated tool names
+        tool_names.difference_update(set(DEPRECATED_BASE_TOOLS))
+
         supplied_ids = set(agent_create.tool_ids or [])
 
         source_ids = agent_create.source_ids or []

letta/services/file_processor/chunker/line_chunker.py

@@ -124,8 +124,8 @@ class LineChunker:
         else:
             line_offset = 0
 
-        # Add line numbers for all strategies
-        content_lines = [f"{i + line_offset}: {line}" for i, line in enumerate(content_lines)]
+        # Add line numbers for all strategies (1-indexed for user display)
+        content_lines = [f"{i + line_offset + 1}: {line}" for i, line in enumerate(content_lines)]
 
         # Add metadata about total chunks
         if add_metadata:
@@ -133,7 +133,10 @@ class LineChunker:
                 "sentences" if strategy == ChunkingStrategy.DOCUMENTATION else "chunks" if strategy == ChunkingStrategy.PROSE else "lines"
             )
             if start is not None and end is not None:
-                content_lines.insert(0, f"[Viewing {chunk_type} {start} to {end-1} (out of {total_chunks} {chunk_type})]")
+                # Display 1-indexed ranges for users
+                start_display = start + 1
+                end_display = end
+                content_lines.insert(0, f"[Viewing {chunk_type} {start_display} to {end_display} (out of {total_chunks} {chunk_type})]")
             else:
                 content_lines.insert(0, f"[Viewing file start (out of {total_chunks} {chunk_type})]")
 

letta/services/files_agents_manager.py

@@ -283,6 +283,40 @@ class FileAgentManager:
             await session.execute(stmt)
             await session.commit()
 
+    @enforce_types
+    @trace_method
+    async def close_all_other_files(self, *, agent_id: str, keep_file_names: List[str], actor: PydanticUser) -> List[str]:
+        """Close every open file for this agent except those in keep_file_names.
+
+        Args:
+            agent_id: ID of the agent
+            keep_file_names: List of file names to keep open
+            actor: User performing the action
+
+        Returns:
+            List of file names that were closed
+        """
+        async with db_registry.async_session() as session:
+            stmt = (
+                update(FileAgentModel)
+                .where(
+                    and_(
+                        FileAgentModel.agent_id == agent_id,
+                        FileAgentModel.organization_id == actor.organization_id,
+                        FileAgentModel.is_open.is_(True),
+                        # Only add the NOT IN filter when there are names to keep
+                        ~FileAgentModel.file_name.in_(keep_file_names) if keep_file_names else True,
+                    )
+                )
+                .values(is_open=False, visible_content=None)
+                .returning(FileAgentModel.file_name)  # Gets the names we closed
+                .execution_options(synchronize_session=False)  # No need to sync ORM state
+            )
+
+            closed_file_names = [row.file_name for row in (await session.execute(stmt))]
+            await session.commit()
+            return closed_file_names
+
     @enforce_types
     @trace_method
     async def enforce_max_open_files_and_open(

letta/services/helpers/agent_manager_helper.py

@@ -1,12 +1,20 @@
 from datetime import datetime
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Set
 
 import numpy as np
 from sqlalchemy import Select, and_, asc, desc, func, literal, nulls_last, or_, select, union_all
 from sqlalchemy.sql.expression import exists
 
 from letta import system
-from letta.constants import IN_CONTEXT_MEMORY_KEYWORD, MAX_EMBEDDING_DIM, STRUCTURED_OUTPUT_MODELS
+from letta.constants import (
+    BASE_MEMORY_TOOLS,
+    BASE_MEMORY_TOOLS_V2,
+    BASE_TOOLS,
+    DEPRECATED_BASE_TOOLS,
+    IN_CONTEXT_MEMORY_KEYWORD,
+    MAX_EMBEDDING_DIM,
+    STRUCTURED_OUTPUT_MODELS,
+)
 from letta.embeddings import embedding_model
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import format_datetime, get_local_time, get_local_time_fast
@@ -1038,3 +1046,10 @@ def build_agent_passage_query(
             query = query.order_by(AgentPassage.created_at.desc(), AgentPassage.id.asc())
 
     return query
+
+
+def calculate_base_tools(is_v2: bool) -> Set[str]:
+    if is_v2:
+        return (set(BASE_TOOLS) - set(DEPRECATED_BASE_TOOLS)) | set(BASE_MEMORY_TOOLS_V2)
+    else:
+        return (set(BASE_TOOLS) - set(DEPRECATED_BASE_TOOLS)) | set(BASE_MEMORY_TOOLS)

letta/services/step_manager.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from enum import Enum
 from typing import List, Literal, Optional
 
 from sqlalchemy import select
@@ -18,6 +19,11 @@ from letta.server.db import db_registry
 from letta.utils import enforce_types
 
 
+class FeedbackType(str, Enum):
+    POSITIVE = "positive"
+    NEGATIVE = "negative"
+
+
 class StepManager:
 
     @enforce_types
@@ -35,6 +41,7 @@ class StepManager:
         agent_id: Optional[str] = None,
         trace_ids: Optional[list[str]] = None,
         feedback: Optional[Literal["positive", "negative"]] = None,
+        has_feedback: Optional[bool] = None,
     ) -> List[PydanticStep]:
         """List all jobs with optional pagination and status filter."""
         async with db_registry.async_session() as session:
@@ -55,6 +62,7 @@ class StepManager:
                 end_date=end_date,
                 limit=limit,
                 ascending=True if order == "asc" else False,
+                has_feedback=has_feedback,
                 **filter_kwargs,
             )
             return [step.to_pydantic() for step in steps]
@@ -154,9 +162,7 @@ class StepManager:
 
     @enforce_types
     @trace_method
-    async def add_feedback_async(
-        self, step_id: str, feedback: Optional[Literal["positive", "negative"]], actor: PydanticUser
-    ) -> PydanticStep:
+    async def add_feedback_async(self, step_id: str, feedback: Optional[FeedbackType], actor: PydanticUser) -> PydanticStep:
         async with db_registry.async_session() as session:
             step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
             if not step:
@@ -250,6 +256,7 @@ class StepManager:
         return job
 
 
+# noinspection PyTypeChecker
 @singleton
 class NoopStepManager(StepManager):
     """
@@ -292,29 +299,4 @@ class NoopStepManager(StepManager):
         job_id: Optional[str] = None,
         step_id: Optional[str] = None,
     ) -> PydanticStep:
-        step_data = {
-            "origin": None,
-            "organization_id": actor.organization_id,
-            "agent_id": agent_id,
-            "provider_id": provider_id,
-            "provider_name": provider_name,
-            "provider_category": provider_category,
-            "model": model,
-            "model_endpoint": model_endpoint,
-            "context_window_limit": context_window_limit,
-            "completion_tokens": usage.completion_tokens,
-            "prompt_tokens": usage.prompt_tokens,
-            "total_tokens": usage.total_tokens,
-            "job_id": job_id,
-            "tags": [],
-            "tid": None,
-            "trace_id": get_trace_id(),  # Get the current trace ID
-        }
-        if step_id:
-            step_data["id"] = step_id
-        async with db_registry.async_session() as session:
-            if job_id:
-                await self._verify_job_access_async(session, job_id, actor, access=["write"])
-            new_step = StepModel(**step_data)
-            await new_step.create_async(session)
-            return new_step.to_pydantic()
+        return

letta/services/tool_executor/files_tool_executor.py

@@ -1,7 +1,9 @@
 import asyncio
 import re
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
+from letta.constants import MAX_FILES_OPEN
+from letta.functions.types import FileOpenRequest
 from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
@@ -31,7 +33,7 @@ class LettaFileToolExecutor(ToolExecutor):
     MAX_REGEX_COMPLEXITY = 1000  # Prevent catastrophic backtracking
     MAX_MATCHES_PER_FILE = 20  # Limit matches per file
     MAX_TOTAL_MATCHES = 50  # Global match limit
-    GREP_TIMEOUT_SECONDS = 30  # Max time for grep operation
+    GREP_TIMEOUT_SECONDS = 30  # Max time for grep_files operation
     MAX_CONTEXT_LINES = 1  # Lines of context around matches
 
     def __init__(
@@ -72,9 +74,8 @@ class LettaFileToolExecutor(ToolExecutor):
             raise ValueError("Agent state is required for file tools")
 
         function_map = {
-            "open_file": self.open_file,
-            "close_file": self.close_file,
-            "grep": self.grep,
+            "open_files": self.open_files,
+            "grep_files": self.grep_files,
             "search_files": self.search_files,
         }
 
@@ -98,56 +99,135 @@ class LettaFileToolExecutor(ToolExecutor):
             )
 
     @trace_method
-    async def open_file(self, agent_state: AgentState, file_name: str, view_range: Optional[Tuple[int, int]] = None) -> str:
-        """Stub for open_file tool."""
-        start, end = None, None
-        if view_range:
-            start, end = view_range
-            if start >= end:
-                raise ValueError(f"Provided view range {view_range} is invalid, starting range must be less than ending range.")
-
-        # TODO: This is inefficient. We can skip the initial DB lookup by preserving on the block metadata what the file_id is
-        file_agent = await self.files_agents_manager.get_file_agent_by_file_name(
-            agent_id=agent_state.id, file_name=file_name, actor=self.actor
-        )
+    async def open_files(self, agent_state: AgentState, file_requests: List[FileOpenRequest], close_all_others: bool = False) -> str:
+        """Open one or more files and load their contents into memory blocks."""
+        # Parse raw dictionaries into FileOpenRequest objects if needed
+        parsed_requests = []
+        for req in file_requests:
+            if isinstance(req, dict):
+                # LLM returned a dictionary, parse it into FileOpenRequest
+                parsed_requests.append(FileOpenRequest(**req))
+            elif isinstance(req, FileOpenRequest):
+                # Already a FileOpenRequest object
+                parsed_requests.append(req)
+            else:
+                raise ValueError(f"Invalid file request type: {type(req)}. Expected dict or FileOpenRequest.")
+
+        file_requests = parsed_requests
+
+        # Validate file count first
+        if len(file_requests) > MAX_FILES_OPEN:
+            raise ValueError(f"Cannot open {len(file_requests)} files: exceeds maximum limit of {MAX_FILES_OPEN} files")
+
+        if not file_requests:
+            raise ValueError("No file requests provided")
 
-        if not file_agent:
-            file_blocks = agent_state.memory.file_blocks
-            file_names = [fb.label for fb in file_blocks]
-            raise ValueError(
-                f"{file_name} not attached - did you get the filename correct? Currently you have the following files attached: {file_names}"
+        # Extract file names for various operations
+        file_names = [req.file_name for req in file_requests]
+
+        # Get all currently attached files for error reporting
+        file_blocks = agent_state.memory.file_blocks
+        attached_file_names = [fb.label for fb in file_blocks]
+
+        # Close all other files if requested
+        closed_by_close_all_others = []
+        if close_all_others:
+            closed_by_close_all_others = await self.files_agents_manager.close_all_other_files(
+                agent_id=agent_state.id, keep_file_names=file_names, actor=self.actor
             )
 
-        file_id = file_agent.file_id
-        file = await self.file_manager.get_file_by_id(file_id=file_id, actor=self.actor, include_content=True)
+        # Process each file
+        opened_files = []
+        all_closed_files = []
+
+        for file_request in file_requests:
+            file_name = file_request.file_name
+            offset = file_request.offset
+            length = file_request.length
+
+            # Convert 1-indexed offset/length to 0-indexed start/end for LineChunker
+            start, end = None, None
+            if offset is not None or length is not None:
+                if offset is not None and offset < 1:
+                    raise ValueError(f"Offset for file {file_name} must be >= 1 (1-indexed), got {offset}")
+                if length is not None and length < 1:
+                    raise ValueError(f"Length for file {file_name} must be >= 1, got {length}")
+
+                # Convert to 0-indexed for LineChunker
+                start = (offset - 1) if offset is not None else None
+                if start is not None and length is not None:
+                    end = start + length
+                else:
+                    end = None
+
+            # Validate file exists and is attached to agent
+            file_agent = await self.files_agents_manager.get_file_agent_by_file_name(
+                agent_id=agent_state.id, file_name=file_name, actor=self.actor
+            )
 
-        # TODO: Inefficient, maybe we can pre-compute this
-        # TODO: This is also not the best way to split things - would be cool to have "content aware" splitting
-        # TODO: Split code differently from large text blurbs
-        content_lines = LineChunker().chunk_text(file_metadata=file, start=start, end=end)
-        visible_content = "\n".join(content_lines)
+            if not file_agent:
+                raise ValueError(
+                    f"{file_name} not attached - did you get the filename correct? Currently you have the following files attached: {attached_file_names}"
+                )
 
-        # Efficiently handle LRU eviction and file opening in a single transaction
-        closed_files, was_already_open = await self.files_agents_manager.enforce_max_open_files_and_open(
-            agent_id=agent_state.id, file_id=file_id, file_name=file_name, actor=self.actor, visible_content=visible_content
-        )
+            file_id = file_agent.file_id
+            file = await self.file_manager.get_file_by_id(file_id=file_id, actor=self.actor, include_content=True)
+
+            # Process file content
+            content_lines = LineChunker().chunk_text(file_metadata=file, start=start, end=end)
+            visible_content = "\n".join(content_lines)
 
-        success_msg = f"Successfully opened file {file_name}, lines {start} to {end} are now visible in memory block <{file_name}>"
-        if closed_files:
+            # Handle LRU eviction and file opening
+            closed_files, was_already_open = await self.files_agents_manager.enforce_max_open_files_and_open(
+                agent_id=agent_state.id, file_id=file_id, file_name=file_name, actor=self.actor, visible_content=visible_content
+            )
+
+            opened_files.append(file_name)
+            all_closed_files.extend(closed_files)
+
+        # Update access timestamps for all opened files efficiently
+        await self.files_agents_manager.mark_access_bulk(agent_id=agent_state.id, file_names=file_names, actor=self.actor)
+
+        # Build success message
+        if len(file_requests) == 1:
+            # Single file - maintain existing format
+            file_request = file_requests[0]
+            file_name = file_request.file_name
+            offset = file_request.offset
+            length = file_request.length
+            if offset is not None and length is not None:
+                end_line = offset + length - 1
+                success_msg = (
+                    f"Successfully opened file {file_name}, lines {offset} to {end_line} are now visible in memory block <{file_name}>"
+                )
+            elif offset is not None:
+                success_msg = f"Successfully opened file {file_name}, lines {offset} to end are now visible in memory block <{file_name}>"
+            else:
+                success_msg = f"Successfully opened file {file_name}, entire file is now visible in memory block <{file_name}>"
+        else:
+            # Multiple files - show individual ranges if specified
+            file_summaries = []
+            for req in file_requests:
+                if req.offset is not None and req.length is not None:
+                    end_line = req.offset + req.length - 1
+                    file_summaries.append(f"{req.file_name} (lines {req.offset}-{end_line})")
+                elif req.offset is not None:
+                    file_summaries.append(f"{req.file_name} (lines {req.offset}-end)")
+                else:
+                    file_summaries.append(req.file_name)
+            success_msg = f"Successfully opened {len(file_requests)} files: {', '.join(file_summaries)}"
+
+        # Add information about closed files
+        if closed_by_close_all_others:
+            success_msg += f"\nNote: Closed {len(closed_by_close_all_others)} file(s) due to close_all_others=True: {', '.join(closed_by_close_all_others)}"
+
+        if all_closed_files:
             success_msg += (
-                f"\nNote: Closed {len(closed_files)} least recently used file(s) due to open file limit: {', '.join(closed_files)}"
+                f"\nNote: Closed {len(all_closed_files)} least recently used file(s) due to open file limit: {', '.join(all_closed_files)}"
             )
 
         return success_msg
 
-    @trace_method
-    async def close_file(self, agent_state: AgentState, file_name: str) -> str:
-        """Stub for close_file tool."""
-        await self.files_agents_manager.update_file_agent_by_name(
-            agent_id=agent_state.id, file_name=file_name, actor=self.actor, is_open=False
-        )
-        return f"Successfully closed file {file_name}, use function calls to re-open file"
-
     def _validate_regex_pattern(self, pattern: str) -> None:
         """Validate regex pattern to prevent catastrophic backtracking."""
         if len(pattern) > self.MAX_REGEX_COMPLEXITY:
@@ -204,7 +284,9 @@ class LettaFileToolExecutor(ToolExecutor):
         return context_lines_with_indicator
 
     @trace_method
-    async def grep(self, agent_state: AgentState, pattern: str, include: Optional[str] = None, context_lines: Optional[int] = 3) -> str:
+    async def grep_files(
+        self, agent_state: AgentState, pattern: str, include: Optional[str] = None, context_lines: Optional[int] = 3
+    ) -> str:
         """
         Search for pattern in all attached files and return matches with context.
 
@@ -213,7 +295,7 @@ class LettaFileToolExecutor(ToolExecutor):
             pattern: Regular expression pattern to search for
             include: Optional pattern to filter filenames to include in the search
             context_lines (Optional[int]): Number of lines of context to show before and after each match.
-                                       Equivalent to `-C` in grep. Defaults to 3.
+                                       Equivalent to `-C` in grep_files. Defaults to 3.
 
         Returns:
             Formatted string with search results, file names, line numbers, and context
@@ -310,20 +392,7 @@ class LettaFileToolExecutor(ToolExecutor):
                 if formatted_lines and formatted_lines[0].startswith("[Viewing"):
                     formatted_lines = formatted_lines[1:]
 
-                # Convert 0-based line numbers to 1-based for grep compatibility
-                corrected_lines = []
-                for line in formatted_lines:
-                    if line and ":" in line:
-                        try:
-                            line_parts = line.split(":", 1)
-                            line_num = int(line_parts[0].strip())
-                            line_content = line_parts[1] if len(line_parts) > 1 else ""
-                            corrected_lines.append(f"{line_num + 1}:{line_content}")
-                        except (ValueError, IndexError):
-                            corrected_lines.append(line)
-                    else:
-                        corrected_lines.append(line)
-                formatted_lines = corrected_lines
+                # LineChunker now returns 1-indexed line numbers, so no conversion needed
 
                 # Search for matches in formatted lines
                 for formatted_line in formatted_lines:

letta/utils.py

@@ -546,7 +546,7 @@ def enforce_types(func):
         for arg_name, arg_value in kwargs.items():
             hint = hints.get(arg_name)
             if hint and not matches_type(arg_value, hint):
-                raise ValueError(f"Argument {arg_name} does not match type {hint}; is {arg_value}")
+                raise ValueError(f"Argument {arg_name} does not match type {hint}; is {arg_value} of type {type(arg_value)}")
 
         return func(*args, **kwargs)
 

{letta_nightly-0.8.6.dev20250627220317.dist-info → letta_nightly-0.8.7.dev20250627220731.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.6.dev20250627220317
+Version: 0.8.7.dev20250627220731
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.8.6.dev20250627220317.dist-info → letta_nightly-0.8.7.dev20250627220731.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=I71uxdVlQqtf-7maevWKQg8Lzv0Hn81WQqmVkYEDtC8,1042
+letta/__init__.py,sha256=lOUklJSTcBdSfR5NdRUgUPfzmqrkcgpB7cHXQlchEdU,1043
 letta/agent.py,sha256=PLTHwDvgl4Nffi_NBm3Jn40H39t7Z6_kZWJ8sswNlpk,89097
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/base_agent.py,sha256=ymn0Uq9VcImoHmmnP0DyXQ-D3trmpcYVCdi7S9p0fKs,6571
@@ -18,7 +18,7 @@ letta/client/client.py,sha256=l_yKUUzl1-qfxFkDHsOMHxSwyzOBbx-2mi0GfI3WlJE,84906
 letta/client/streaming.py,sha256=UsDS_tDTsA3HgYryIDvGGmx_dWfnfQwtmEwLi4Z89Ik,4701
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
-letta/constants.py,sha256=84Y0ju1_MLQBo4jkgVci-8ctZMUXxxm2WNYv8oefO7A,14242
+letta/constants.py,sha256=pOLogWzDCJhSr2rp-hPhOFRt0INSLpFx-7M2uJw7NEs,14312
 letta/data_sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/data_sources/connectors.py,sha256=V8mUgE3V6CX-CcOyvkPSQ_ZWP2VtuqgTEXkCN1j0p68,7920
 letta/data_sources/connectors_helper.py,sha256=oQpVlc-BjSz9sTZ7sp4PsJSXJbBKpZPi3Dam03CURTQ,3376
@@ -32,7 +32,7 @@ letta/functions/composio_helpers.py,sha256=mpybCYcB93HWoKrmQIqcuRQG9IH2lHWhsPQx2
 letta/functions/function_sets/base.py,sha256=FS-LRbvzO-duSUy0yLP_fBk2WSs4NAaaTAUuhl2ZS-I,16154
 letta/functions/function_sets/builtin.py,sha256=tm9KWrWZKhXMoXgd7PSsp-WfS8chhFe7gIdQhT1N5E4,2027
 letta/functions/function_sets/extras.py,sha256=mG7jCd2RUsf1w9G8mVcv26twJWpiDhbWI6VvnLZoEOk,4899
-letta/functions/function_sets/files.py,sha256=baXefT4pyUqaF7jb_731V4m4q-gpx62wvZ7DNCBo6Eg,2252
+letta/functions/function_sets/files.py,sha256=X8BOQiQ8T1f7E8juZ0V-UoKNIkAZluWApeo1nHDQ6TI,2724
 letta/functions/function_sets/multi_agent.py,sha256=Dy0lW2MvgbAtTkdmVoMelSDqf9uuiPkZWIpfDBYqap8,5435
 letta/functions/function_sets/voice.py,sha256=_gmFEj3fSFb-4eMM-ddSOm-Vk1ShIVjpchZI7MQKwSA,3191
 letta/functions/functions.py,sha256=JVweekyBSlgquNt2Sa4CID7WLE_wIIB7Dl2SHK2gBtM,5940
@@ -45,13 +45,13 @@ letta/functions/mcp_client/sse_client.py,sha256=QDC29Re2mdGji77YrUk7JXfTVJeS6039
 letta/functions/mcp_client/stdio_client.py,sha256=-SymmkO_KNFZUP5e5mhcidpyyXBv6Xh72yUiMnv_bFw,4709
 letta/functions/mcp_client/types.py,sha256=7WoTIAA5NhgmpVwdOxcE3FBn8T_TUVOhE6hLPeSubE0,5703
 letta/functions/prompts.py,sha256=jNl83xjNpoSs8KzGtuc6jzN8jp_T4BC_5f4FMJ88_K0,1145
-letta/functions/schema_generator.py,sha256=YDAyqtG_moh9bxrzBAyLfEFTQCMGZHjFlpoVvuKi7XA,23356
-letta/functions/types.py,sha256=t7JAL3cjtrGGNI_U5il4rQYme4iGkLSg5Y1nDWjOtfU,254
+letta/functions/schema_generator.py,sha256=kq5m4utb-uGYmHcu3io3X5MZ_czlOPng9USPUL83VA4,28177
+letta/functions/types.py,sha256=mrKmfWaS1mx1m6e9E6ZahhKW7-IedPCf0AjvUZlKhhE,718
 letta/groups/dynamic_multi_agent.py,sha256=OLCxhICFLYyx8wjKGPr1INc6pniEuk4YGZyZhq2vkiY,12230
 letta/groups/helpers.py,sha256=VABgj684cInv5TXUZ31baTX4nXLghNe0DCnPiEBdjHw,4435
 letta/groups/round_robin_multi_agent.py,sha256=uUJff0bO68udOREiKFWeS7eEQlk3bF7hcfLSFXMScqI,6999
 letta/groups/sleeptime_multi_agent.py,sha256=Wo9uc-ZD99SlW3bcP91EwXc3kIX5t8sCcY1JMJjuiRY,10462
-letta/groups/sleeptime_multi_agent_v2.py,sha256=heMOb-vo-cNRLwSciDoIYdJFD6My5y4r3gNFeMX3l_4,13379
+letta/groups/sleeptime_multi_agent_v2.py,sha256=Vgn_Mhz5pGHX4ICLv-vS_j5Fd1Kb7W-1U-YayGAJlVE,13531
 letta/groups/supervisor_multi_agent.py,sha256=ml8Gi9gyVjPuVZjAJAkpGZDjnM7GOS50NkKf5SIutvQ,4455
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/composio_helpers.py,sha256=MwfmLt7tgjvxAXLHpx9pa5QolxcqoCbofb-30-DVpsI,1714
@@ -171,7 +171,7 @@ letta/orm/provider_trace.py,sha256=CJMGz-rLqagJ-yXh9SJRbiGr5nAYdxY524hmiTgDFx4,1
 letta/orm/sandbox_config.py,sha256=zOCvORexDBt16mc6A3U65EI6_2Xe3Roh7k2asLeFMps,4242
 letta/orm/source.py,sha256=rtehzez80rRrJigXeRBgTlfTZEUy6cVqDizWEN2tvuY,2224
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
-letta/orm/sqlalchemy_base.py,sha256=W9JkvSCjWEMscAlfPKC1GHKM6PoVFTDHxjrGBq6MVgQ,44042
+letta/orm/sqlalchemy_base.py,sha256=L6dX5_InnYWB9HRhYAY2j_yA9Oye5uxmmSIq9PCuEDo,44399
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
 letta/orm/step.py,sha256=SLsLY1g4nuUeI47q9rlXPBCSVUNX3lxYAYAIqxy-YK4,3517
 letta/orm/tool.py,sha256=oTDbvSNNW_jHjYbJqqsLLuXf9uFRTZTZh33TXAcZ898,2839
@@ -227,7 +227,7 @@ letta/prompts/system/voice_chat.txt,sha256=Q_vd2Q08z6qTIVeMML0z9706NG8aAq-scxvi-
 letta/prompts/system/voice_sleeptime.txt,sha256=LPh-XjAthvsdEkXoZ4NTzTUuMbMsMkoDl9ofCUJC7Us,3696
 letta/prompts/system/workflow.txt,sha256=pLOaUDsNFAzLs4xb9JgGtd1w-lrq0Q1E7SpFBttXYCI,834
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/schemas/agent.py,sha256=6BNV57XhMMDDQ8YZrFEurNw1L_srx0Cqen7xJyqfNKU,23908
+letta/schemas/agent.py,sha256=AMbKzxCVvGH488jOLy4X8XoUDrUIcWACu8054-djH6A,23874
 letta/schemas/block.py,sha256=awxCQKxmv4I4k9Au5h-a2RCeSVF54EfWyBQPtHRwuNQ,5585
 letta/schemas/embedding_config.py,sha256=By79UpBnjh6lg9q6c12th6EfzLSSUVgRbwofnhoI4hM,3762
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
@@ -310,7 +310,7 @@ letta/server/rest_api/routers/v1/providers.py,sha256=8SJ_RsSk7L4nh1f_uFE31JOxefm
 letta/server/rest_api/routers/v1/runs.py,sha256=vieUp7uTvRTdAte0Nw1bqX2APMATZhKTr2R1HVNJT74,8879
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=pKuy88GD3atrBkKa7VVfKTjg8Y07e1vVtdw4TtxkQBk,8910
 letta/server/rest_api/routers/v1/sources.py,sha256=-_jWL2jDqOt2r0IUUxjHjxf4TZhAJDdt7_J5f_kGF_U,17094
-letta/server/rest_api/routers/v1/steps.py,sha256=uNEQVEeRU9RwYuD2Dz1PzZy04nyvMSTY0Tx0WrMEgVs,4362
+letta/server/rest_api/routers/v1/steps.py,sha256=7WptAAnx0FmTQlkRbdGqt01bH0KrwSbCBajOI_RTfOk,4554
 letta/server/rest_api/routers/v1/tags.py,sha256=ef94QitUSJ3NQVffWF1ZqANUZ2b2jRyGHp_I3UUjhno,912
 letta/server/rest_api/routers/v1/telemetry.py,sha256=z53BW3Pefi3eWy47FPJyGhFWbZicX9jPJUi5LC5c3sk,790
 letta/server/rest_api/routers/v1/tools.py,sha256=JYHy522vclWJXouzLpLQJGEXLgTtoWk4w6LQgiUdtMQ,27672
@@ -319,7 +319,7 @@ letta/server/rest_api/routers/v1/voice.py,sha256=ghMBp5Uovbf0-3nN6d9P5kpl1hHACLR
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/streaming_response.py,sha256=yYTuZHfuZ-DYYbA1Ta6axkBn5MvC6OHuVRHSiBqRNUk,3939
 letta/server/rest_api/utils.py,sha256=6Ar4r3eohMRr5_p4e07x54ILZC5X4A9XZnupzQRasQA,17808
-letta/server/server.py,sha256=JtbXHs4FOcqewxPn3Ol-1XnH4bzcnIdnJAlGQPudClQ,113661
+letta/server/server.py,sha256=kakYFBV22esqMWRgEHJ69wOLYFRz7kpHPvw8qkwMGiQ,113681
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -333,7 +333,7 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=w636-jxEp1YglX3z9fSWotmlrvFJcHBBOV2gzNMB1c8,120893
+letta/services/agent_manager.py,sha256=BAj7wu74BXp6U7keQ2YPmIgavCVN9MCYcf_9J0Fscl8,121041
 letta/services/block_manager.py,sha256=YwDGdy6f6MNXVXVOxIMOOP6IEWT8h-k5uQlveof0pyE,22744
 letta/services/context_window_calculator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/context_window_calculator/context_window_calculator.py,sha256=H0-Ello1DHV28MnzMseWrg--jarDc6YwCcgwPlWjtZk,6527
@@ -341,7 +341,7 @@ letta/services/context_window_calculator/token_counter.py,sha256=Ai9-aPkNvhhMTj9
 letta/services/file_manager.py,sha256=qSdkVvouQbpZrCjh90XikUm4jlndm7Fxz4w2sMxt17E,8554
 letta/services/file_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/chunker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/file_processor/chunker/line_chunker.py,sha256=Lm5iZR7tFyOlew8XrZpowx-0wbIlluXQXZ6R-VcDY8U,5576
+letta/services/file_processor/chunker/line_chunker.py,sha256=6VGwthka1Xg9z2r84YbaSG6G_UmrQnbe7aELgkmp2d4,5752
 letta/services/file_processor/chunker/llama_index_chunker.py,sha256=dEBf33TifD_BcxjNAULim9NDF8VPG8EQkjeR9saK4t4,3982
 letta/services/file_processor/embedder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/embedder/openai_embedder.py,sha256=BjKsNqh_nfNIDVWkCR2noFX7E6Mr68FQtj79F2xeCpM,3545
@@ -351,9 +351,9 @@ letta/services/file_processor/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 letta/services/file_processor/parser/base_parser.py,sha256=WfnXP6fL-xQz4eIHEWa6-ZNEAARbF_alowqH4BAUzJo,238
 letta/services/file_processor/parser/mistral_parser.py,sha256=Hzsrm36HbKQ7CWljTZT1RgbvxE4gvSBq76Ucj80jjeQ,2322
 letta/services/file_processor/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/files_agents_manager.py,sha256=xBzXPrpbUF-HMMcK0js70QOgLv28AeJ21U0wC2Y9CBs,16592
+letta/services/files_agents_manager.py,sha256=OnwWz772QjCdlvNf-Di3KBeUEV7XrvSK0grGMvglv1o,18073
 letta/services/group_manager.py,sha256=X2gKKUGKTXGRMC8YjwmE6EOB1cVM4lo31eCnmog7dPQ,23368
-letta/services/helpers/agent_manager_helper.py,sha256=2zPnxs1QFo_uGv1fG-pqwTQ-oFfgcqNjk9deLVNgby4,43134
+letta/services/helpers/agent_manager_helper.py,sha256=drZiCO_GekinY7F5lYpa_Ykckb63np703InONJIgnys,43502
 letta/services/helpers/tool_execution_helper.py,sha256=45L7woJ98jK5MQAnhE_4NZdCeyOOzC4328FTQPM7iTA,9159
 letta/services/helpers/tool_parser_helper.py,sha256=EI5tcre-D5U3mEzIMhfkAGlUwYckW1JlCJ-iqwoTTrc,4336
 letta/services/identity_manager.py,sha256=L8EYGYXA9sveLwPCTYZIdYZwOMnHex47TBiMYcco_y4,10575
@@ -373,7 +373,7 @@ letta/services/per_agent_lock_manager.py,sha256=cMaW8r-qhucQbiK27jVqz8wzhlr2yuRN
 letta/services/provider_manager.py,sha256=mEtiBF7kJgSzDwwyqSmWLT6kgvWPk-FERZ9Zw8QKpHw,9557
 letta/services/sandbox_config_manager.py,sha256=fcJkXCaA6vmrnTusHhns-c_aRXcPlFLICPGdWDaY8XQ,26138
 letta/services/source_manager.py,sha256=bfkfubjvlvnpkd-W6FcoQ0qDYxWkajut0ZY1cI56bbE,6197
-letta/services/step_manager.py,sha256=BqCz9guHYJqx9bu0wn2YCqcIHv80upT0eddyxiP0yvo,11452
+letta/services/step_manager.py,sha256=7eSmV6czRhxZc_Fd2tIXetffRsQbh0Qf5x3tLSe9pRM,10568
 letta/services/summarizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7ozi7A,208
 letta/services/summarizer/summarizer.py,sha256=9UHxZ1YPIIUWMK5_kz4_Kf5Qj9eHOo2zeEcmbzfUi_o,9275
@@ -382,7 +382,7 @@ letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 letta/services/tool_executor/builtin_tool_executor.py,sha256=bOrw0qzBf1c9e-NkeR1QAPFV8BK-FrBqIRqpPL7jJeM,17460
 letta/services/tool_executor/composio_tool_executor.py,sha256=ia2AA_WDOseR8Ylam-HEayR7OiyfNSb1sSUrjwqlmFM,2308
 letta/services/tool_executor/core_tool_executor.py,sha256=YfUTxo78FNFPFNc6714RR_ztrf9I1GATs4cZhSbiEag,20503
-letta/services/tool_executor/files_tool_executor.py,sha256=lBjZwjJrDu2JTzRih4tywLwxyxMRc-zipr2I47c_KHk,21133
+letta/services/tool_executor/files_tool_executor.py,sha256=xrl71vmIFKC2pFDKUTjWPSpPSBm8WUcqH52HnPu09zA,24154
 letta/services/tool_executor/mcp_tool_executor.py,sha256=x8V8J4Xi1ZVbwfaR_IwnUGRrD9w5wgV4G54sjraVBw4,1676
 letta/services/tool_executor/multi_agent_tool_executor.py,sha256=uBlUqDtS5JYb-bPDiucZBzwtSuoV3NIhhsmzniG5fDA,4464
 letta/services/tool_executor/tool_execution_manager.py,sha256=flCbTmtxZvYNcTGNC2MrYWkdPIatqFPTWnI8oJUWTIY,6399
@@ -404,9 +404,9 @@ letta/templates/sandbox_code_file.py.j2,sha256=zgzaboDZVtM15XkxILnhiKisF7DSUoI2Y
 letta/templates/sandbox_code_file_async.py.j2,sha256=hL6UWt4L16o79OPOBq1_Cw7gR5-gpaR_esbmU8bSp8w,1805
 letta/templates/template_helper.py,sha256=uHWO1PukgMoIIvgqQdPyHq3o3CQ6mcjUjTGvx9VLGkk,409
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta/utils.py,sha256=ZfyAcRBITlYs2XM5fHj_Lp08fPFMBMaQSPbfYlETbDs,33198
-letta_nightly-0.8.6.dev20250627220317.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.8.6.dev20250627220317.dist-info/METADATA,sha256=Ufu1w-A46HxtEzzu_gAqGO1oF9AZFANSvsKf_dkWOOA,22841
-letta_nightly-0.8.6.dev20250627220317.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.8.6.dev20250627220317.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.8.6.dev20250627220317.dist-info/RECORD,,
+letta/utils.py,sha256=WkPJD9cs00CKgu5ezcTz5vSP76npyuBOpK7paQDQtxk,33224
+letta_nightly-0.8.7.dev20250627220731.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.8.7.dev20250627220731.dist-info/METADATA,sha256=oFq4yuyZJbmGhDMzJ3VZj8IXdRgr0GtmLt7Tt4tdkOw,22841
+letta_nightly-0.8.7.dev20250627220731.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.8.7.dev20250627220731.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.8.7.dev20250627220731.dist-info/RECORD,,