letta-nightly 0.8.5.dev20250625104328__py3-none-any.whl → 0.8.6.dev20250626104326__py3-none-any.whl

letta/services/agent_manager.py

@@ -15,6 +15,7 @@ from letta.constants import (
     BASE_TOOLS,
     BASE_VOICE_SLEEPTIME_CHAT_TOOLS,
     BASE_VOICE_SLEEPTIME_TOOLS,
+    DEFAULT_TIMEZONE,
     FILES_TOOLS,
     MULTI_AGENT_TOOLS,
 )
@@ -287,7 +288,7 @@ class AgentManager:
                 tool_rules = list(agent_create.tool_rules or [])
                 if agent_create.include_base_tool_rules:
                     for tn in tool_names:
-                        if tn in {"send_message", "send_message_to_agent_async", "memory_finish_edits"}:
+                        if tn in {"send_message", "memory_finish_edits"}:
                             tool_rules.append(TerminalToolRule(tool_name=tn))
                         elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_SLEEPTIME_TOOLS):
                             tool_rules.append(ContinueToolRule(tool_name=tn))
@@ -317,6 +318,7 @@ class AgentManager:
                     response_format=agent_create.response_format,
                     created_by_id=actor.id,
                     last_updated_by_id=actor.id,
+                    timezone=agent_create.timezone,
                 )
 
                 if _test_only_force_id:
@@ -450,7 +452,7 @@ class AgentManager:
                 tool_rules = list(agent_create.tool_rules or [])
                 if agent_create.include_base_tool_rules:
                     for tn in tool_names:
-                        if tn in {"send_message", "send_message_to_agent_async", "memory_finish_edits"}:
+                        if tn in {"send_message", "memory_finish_edits"}:
                             tool_rules.append(TerminalToolRule(tool_name=tn))
                         elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_MEMORY_TOOLS_V2 + BASE_SLEEPTIME_TOOLS):
                             tool_rules.append(ContinueToolRule(tool_name=tn))
@@ -480,6 +482,7 @@ class AgentManager:
                     response_format=agent_create.response_format,
                     created_by_id=actor.id,
                     last_updated_by_id=actor.id,
+                    timezone=agent_create.timezone if agent_create.timezone else DEFAULT_TIMEZONE,
                 )
 
                 if _test_only_force_id:
@@ -539,6 +542,7 @@ class AgentManager:
                 new_agent.message_ids = [msg.id for msg in init_messages]
 
             await session.refresh(new_agent)
+
             result = await new_agent.to_pydantic_async()
 
         await self.message_manager.create_many_messages_async(pydantic_msgs=init_messages, actor=actor)
@@ -561,7 +565,9 @@ class AgentManager:
             # Don't use anything else in the pregen sequence, instead use the provided sequence
             init_messages = [system_message_obj]
             init_messages.extend(
-                package_initial_message_sequence(agent_state.id, supplied_initial_message_sequence, agent_state.llm_config.model, actor)
+                package_initial_message_sequence(
+                    agent_state.id, supplied_initial_message_sequence, agent_state.llm_config.model, agent_state.timezone, actor
+                )
             )
         else:
             init_messages = [
@@ -1424,6 +1430,7 @@ class AgentManager:
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
+            timezone=agent_state.timezone,
             previous_message_count=num_messages - len(agent_state.message_ids),
             archival_memory_size=num_archival_memories,
         )
@@ -1498,6 +1505,7 @@ class AgentManager:
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
+            timezone=agent_state.timezone,
             previous_message_count=num_messages - len(agent_state.message_ids),
             archival_memory_size=num_archival_memories,
             tool_rules_solver=tool_rules_solver,
@@ -1699,6 +1707,13 @@ class AgentManager:
 
         return agent_state
 
+    @trace_method
+    @enforce_types
+    async def refresh_file_blocks(self, agent_state: PydanticAgentState, actor: PydanticUser) -> PydanticAgentState:
+        file_blocks = await self.file_agent_manager.list_files_for_agent(agent_id=agent_state.id, actor=actor, return_as_blocks=True)
+        agent_state.memory.file_blocks = [b for b in file_blocks if b is not None]
+        return agent_state
+
     # ======================================================================================================================
     # Source Management
     # ======================================================================================================================
@@ -1954,25 +1969,61 @@ class AgentManager:
     @trace_method
     @enforce_types
     def attach_block(self, agent_id: str, block_id: str, actor: PydanticUser) -> PydanticAgentState:
-        """Attaches a block to an agent."""
+        """Attaches a block to an agent. For sleeptime agents, also attaches to paired agents in the same group."""
         with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
 
+            # Attach block to the main agent
             agent.core_memory.append(block)
-            agent.update(session, actor=actor)
+            agent.update(session, actor=actor, no_commit=True)
+
+            # If agent is part of a sleeptime group, attach block to the sleeptime_agent
+            if agent.multi_agent_group and agent.multi_agent_group.manager_type == ManagerType.sleeptime:
+                group = agent.multi_agent_group
+                # Find the sleeptime_agent in the group
+                for other_agent_id in group.agent_ids or []:
+                    if other_agent_id != agent_id:
+                        try:
+                            other_agent = AgentModel.read(db_session=session, identifier=other_agent_id, actor=actor)
+                            if other_agent.agent_type == AgentType.sleeptime_agent and block not in other_agent.core_memory:
+                                other_agent.core_memory.append(block)
+                                other_agent.update(session, actor=actor, no_commit=True)
+                        except NoResultFound:
+                            # Agent might not exist anymore, skip
+                            continue
+            session.commit()
+
             return agent.to_pydantic()
 
     @trace_method
     @enforce_types
     async def attach_block_async(self, agent_id: str, block_id: str, actor: PydanticUser) -> PydanticAgentState:
-        """Attaches a block to an agent."""
+        """Attaches a block to an agent. For sleeptime agents, also attaches to paired agents in the same group."""
         async with db_registry.async_session() as session:
             agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
             block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
 
+            # Attach block to the main agent
             agent.core_memory.append(block)
-            await agent.update_async(session, actor=actor)
+            await agent.update_async(session)
+
+            # If agent is part of a sleeptime group, attach block to the sleeptime_agent
+            if agent.multi_agent_group and agent.multi_agent_group.manager_type == ManagerType.sleeptime:
+                group = agent.multi_agent_group
+                # Find the sleeptime_agent in the group
+                for other_agent_id in group.agent_ids or []:
+                    if other_agent_id != agent_id:
+                        try:
+                            other_agent = await AgentModel.read_async(db_session=session, identifier=other_agent_id, actor=actor)
+                            if other_agent.agent_type == AgentType.sleeptime_agent and block not in other_agent.core_memory:
+                                other_agent.core_memory.append(block)
+                                await other_agent.update_async(session, actor=actor, no_commit=True)
+                        except NoResultFound:
+                            # Agent might not exist anymore, skip
+                            continue
+            session.commit()
+
             return await agent.to_pydantic_async()
 
     @trace_method

letta/services/block_manager.py

@@ -7,12 +7,12 @@ from sqlalchemy.orm import Session
 from letta.log import get_logger
 from letta.orm.block import Block as BlockModel
 from letta.orm.block_history import BlockHistory
-from letta.orm.enums import ActorType
 from letta.orm.errors import NoResultFound
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import BlockUpdate
+from letta.schemas.enums import ActorType
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.utils import enforce_types

letta/services/file_processor/chunker/line_chunker.py

@@ -99,10 +99,11 @@ class LineChunker:
         return [line for line in lines if line.strip()]
 
     def chunk_text(
-        self, text: str, file_metadata: FileMetadata, start: Optional[int] = None, end: Optional[int] = None, add_metadata: bool = True
+        self, file_metadata: FileMetadata, start: Optional[int] = None, end: Optional[int] = None, add_metadata: bool = True
     ) -> List[str]:
         """Content-aware text chunking based on file type"""
         strategy = self._determine_chunking_strategy(file_metadata)
+        text = file_metadata.content
 
         # Apply the appropriate chunking strategy
         if strategy == ChunkingStrategy.DOCUMENTATION:

letta/services/file_processor/file_processor.py

@@ -75,21 +75,14 @@ class FileProcessor:
 
             # update file with raw text
             raw_markdown_text = "".join([page.markdown for page in ocr_response.pages])
-            file_metadata = await self.file_manager.upsert_file_content(file_id=file_metadata.id, text=raw_markdown_text, actor=self.actor)
             file_metadata = await self.file_manager.update_file_status(
                 file_id=file_metadata.id, actor=self.actor, processing_status=FileProcessingStatus.EMBEDDING
             )
-
-            # Insert to agent context window
-            # TODO: Rethink this line chunking mechanism
-            content_lines = self.line_chunker.chunk_text(text=raw_markdown_text, file_metadata=file_metadata)
-            visible_content = "\n".join(content_lines)
+            file_metadata = await self.file_manager.upsert_file_content(file_id=file_metadata.id, text=raw_markdown_text, actor=self.actor)
 
             await server.insert_file_into_context_windows(
                 source_id=source_id,
-                text=visible_content,
-                file_id=file_metadata.id,
-                file_name=file_metadata.file_name,
+                file_metadata_with_content=file_metadata,
                 actor=self.actor,
                 agent_states=agent_states,
             )

letta/services/files_agents_manager.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 
 from sqlalchemy import and_, func, select, update
 
+from letta.constants import MAX_FILES_OPEN
 from letta.orm.errors import NoResultFound
 from letta.orm.files_agents import FileAgent as FileAgentModel
 from letta.otel.tracing import trace_method
@@ -27,51 +28,66 @@ class FileAgentManager:
         actor: PydanticUser,
         is_open: bool = True,
         visible_content: Optional[str] = None,
-    ) -> PydanticFileAgent:
+    ) -> tuple[PydanticFileAgent, List[str]]:
         """
-        Idempotently attach *file_id* to *agent_id*.
+        Idempotently attach *file_id* to *agent_id* with LRU enforcement.
 
         • If the row already exists → update `is_open`, `visible_content`
           and always refresh `last_accessed_at`.
         • Otherwise create a brand-new association.
+        • If is_open=True, enforces MAX_FILES_OPEN using LRU eviction.
+
+        Returns:
+            Tuple of (file_agent, closed_file_names)
         """
-        async with db_registry.async_session() as session:
-            query = select(FileAgentModel).where(
-                and_(
-                    FileAgentModel.agent_id == agent_id,
-                    FileAgentModel.file_id == file_id,
-                    FileAgentModel.file_name == file_name,
-                    FileAgentModel.organization_id == actor.organization_id,
-                )
+        if is_open:
+            # Use the efficient LRU + open method
+            closed_files, was_already_open = await self.enforce_max_open_files_and_open(
+                agent_id=agent_id, file_id=file_id, file_name=file_name, actor=actor, visible_content=visible_content or ""
             )
-            existing = await session.scalar(query)
 
-            now_ts = datetime.now(timezone.utc)
+            # Get the updated file agent to return
+            file_agent = await self.get_file_agent_by_id(agent_id=agent_id, file_id=file_id, actor=actor)
+            return file_agent, closed_files
+        else:
+            # Original logic for is_open=False
+            async with db_registry.async_session() as session:
+                query = select(FileAgentModel).where(
+                    and_(
+                        FileAgentModel.agent_id == agent_id,
+                        FileAgentModel.file_id == file_id,
+                        FileAgentModel.file_name == file_name,
+                        FileAgentModel.organization_id == actor.organization_id,
+                    )
+                )
+                existing = await session.scalar(query)
 
-            if existing:
-                # update only the fields that actually changed
-                if existing.is_open != is_open:
-                    existing.is_open = is_open
+                now_ts = datetime.now(timezone.utc)
 
-                if visible_content is not None and existing.visible_content != visible_content:
-                    existing.visible_content = visible_content
+                if existing:
+                    # update only the fields that actually changed
+                    if existing.is_open != is_open:
+                        existing.is_open = is_open
 
-                existing.last_accessed_at = now_ts
+                    if visible_content is not None and existing.visible_content != visible_content:
+                        existing.visible_content = visible_content
 
-                await existing.update_async(session, actor=actor)
-                return existing.to_pydantic()
+                    existing.last_accessed_at = now_ts
 
-            assoc = FileAgentModel(
-                agent_id=agent_id,
-                file_id=file_id,
-                file_name=file_name,
-                organization_id=actor.organization_id,
-                is_open=is_open,
-                visible_content=visible_content,
-                last_accessed_at=now_ts,
-            )
-            await assoc.create_async(session, actor=actor)
-            return assoc.to_pydantic()
+                    await existing.update_async(session, actor=actor)
+                    return existing.to_pydantic(), []
+
+                assoc = FileAgentModel(
+                    agent_id=agent_id,
+                    file_id=file_id,
+                    file_name=file_name,
+                    organization_id=actor.organization_id,
+                    is_open=is_open,
+                    visible_content=visible_content,
+                    last_accessed_at=now_ts,
+                )
+                await assoc.create_async(session, actor=actor)
+                return assoc.to_pydantic(), []
 
     @enforce_types
     @trace_method
@@ -192,10 +208,7 @@ class FileAgentManager:
     @enforce_types
     @trace_method
     async def list_files_for_agent(
-        self,
-        agent_id: str,
-        actor: PydanticUser,
-        is_open_only: bool = False,
+        self, agent_id: str, actor: PydanticUser, is_open_only: bool = False, return_as_blocks: bool = False
     ) -> List[PydanticFileAgent]:
         """Return associations for *agent_id* (filtering by `is_open` if asked)."""
         async with db_registry.async_session() as session:
@@ -207,7 +220,11 @@ class FileAgentManager:
                 conditions.append(FileAgentModel.is_open.is_(True))
 
             rows = (await session.execute(select(FileAgentModel).where(and_(*conditions)))).scalars().all()
-            return [r.to_pydantic() for r in rows]
+
+            if return_as_blocks:
+                return [r.to_pydantic_block() for r in rows]
+            else:
+                return [r.to_pydantic() for r in rows]
 
     @enforce_types
     @trace_method
@@ -246,6 +263,129 @@ class FileAgentManager:
             await session.execute(stmt)
             await session.commit()
 
+    @enforce_types
+    @trace_method
+    async def mark_access_bulk(self, *, agent_id: str, file_names: List[str], actor: PydanticUser) -> None:
+        """Update `last_accessed_at = now()` for multiple files by name without loading rows."""
+        if not file_names:
+            return
+
+        async with db_registry.async_session() as session:
+            stmt = (
+                update(FileAgentModel)
+                .where(
+                    FileAgentModel.agent_id == agent_id,
+                    FileAgentModel.file_name.in_(file_names),
+                    FileAgentModel.organization_id == actor.organization_id,
+                )
+                .values(last_accessed_at=func.now())
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+    @enforce_types
+    @trace_method
+    async def enforce_max_open_files_and_open(
+        self, *, agent_id: str, file_id: str, file_name: str, actor: PydanticUser, visible_content: str
+    ) -> tuple[List[str], bool]:
+        """
+        Efficiently handle LRU eviction and file opening in a single transaction.
+
+        Args:
+            agent_id: ID of the agent
+            file_id: ID of the file to open
+            file_name: Name of the file to open
+            actor: User performing the action
+            visible_content: Content to set for the opened file
+
+        Returns:
+            Tuple of (closed_file_names, file_was_already_open)
+        """
+        async with db_registry.async_session() as session:
+            # Single query to get ALL open files for this agent, ordered by last_accessed_at (oldest first)
+            open_files_query = (
+                select(FileAgentModel)
+                .where(
+                    and_(
+                        FileAgentModel.agent_id == agent_id,
+                        FileAgentModel.organization_id == actor.organization_id,
+                        FileAgentModel.is_open.is_(True),
+                    )
+                )
+                .order_by(FileAgentModel.last_accessed_at.asc())  # Oldest first for LRU
+            )
+
+            all_open_files = (await session.execute(open_files_query)).scalars().all()
+
+            # Check if the target file exists (open or closed)
+            target_file_query = select(FileAgentModel).where(
+                and_(
+                    FileAgentModel.agent_id == agent_id,
+                    FileAgentModel.organization_id == actor.organization_id,
+                    FileAgentModel.file_name == file_name,
+                )
+            )
+            file_to_open = await session.scalar(target_file_query)
+
+            # Separate the file we're opening from others (only if it's currently open)
+            other_open_files = []
+            for file_agent in all_open_files:
+                if file_agent.file_name != file_name:
+                    other_open_files.append(file_agent)
+
+            file_was_already_open = file_to_open is not None and file_to_open.is_open
+
+            # Calculate how many files need to be closed
+            current_other_count = len(other_open_files)
+            target_other_count = MAX_FILES_OPEN - 1  # Reserve 1 slot for file we're opening
+
+            closed_file_names = []
+            if current_other_count > target_other_count:
+                files_to_close_count = current_other_count - target_other_count
+                files_to_close = other_open_files[:files_to_close_count]  # Take oldest
+
+                # Bulk close files using a single UPDATE query
+                file_ids_to_close = [f.file_id for f in files_to_close]
+                closed_file_names = [f.file_name for f in files_to_close]
+
+                if file_ids_to_close:
+                    close_stmt = (
+                        update(FileAgentModel)
+                        .where(
+                            and_(
+                                FileAgentModel.agent_id == agent_id,
+                                FileAgentModel.file_id.in_(file_ids_to_close),
+                                FileAgentModel.organization_id == actor.organization_id,
+                            )
+                        )
+                        .values(is_open=False, visible_content=None)
+                    )
+                    await session.execute(close_stmt)
+
+            # Open the target file (update or create)
+            now_ts = datetime.now(timezone.utc)
+
+            if file_to_open:
+                # Update existing file
+                file_to_open.is_open = True
+                file_to_open.visible_content = visible_content
+                file_to_open.last_accessed_at = now_ts
+                await file_to_open.update_async(session, actor=actor)
+            else:
+                # Create new file association
+                new_file_agent = FileAgentModel(
+                    agent_id=agent_id,
+                    file_id=file_id,
+                    file_name=file_name,
+                    organization_id=actor.organization_id,
+                    is_open=True,
+                    visible_content=visible_content,
+                    last_accessed_at=now_ts,
+                )
+                await new_file_agent.create_async(session, actor=actor)
+
+            return closed_file_names, file_was_already_open
+
     async def _get_association_by_file_id(self, session, agent_id: str, file_id: str, actor: PydanticUser) -> FileAgentModel:
         q = select(FileAgentModel).where(
             and_(