letta-nightly 0.11.4.dev20250825104222__py3-none-any.whl → 0.11.5__py3-none-any.whl

letta/services/helpers/agent_manager_helper.py

@@ -21,7 +21,7 @@ from letta.constants import (
     STRUCTURED_OUTPUT_MODELS,
 )
 from letta.helpers import ToolRulesSolver
-from letta.helpers.datetime_helpers import format_datetime, get_local_time, get_local_time_fast
+from letta.helpers.datetime_helpers import get_local_time
 from letta.llm_api.llm_client import LLMClient
 from letta.orm.agent import Agent as AgentModel
 from letta.orm.agents_tags import AgentsTags
@@ -33,6 +33,7 @@ from letta.orm.sources_agents import SourcesAgents
 from letta.orm.sqlite_functions import adapt_array
 from letta.otel.tracing import trace_method
 from letta.prompts import gpt_system
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole
@@ -217,60 +218,6 @@ def derive_system_message(agent_type: AgentType, enable_sleeptime: Optional[bool
     return system
 
 
-# TODO: This code is kind of wonky and deserves a rewrite
-def compile_memory_metadata_block(
-    memory_edit_timestamp: datetime,
-    timezone: str,
-    previous_message_count: int = 0,
-    archival_memory_size: Optional[int] = 0,
-) -> str:
-    """
-    Generate a memory metadata block for the agent's system prompt.
-
-    This creates a structured metadata section that informs the agent about
-    the current state of its memory systems, including timing information
-    and memory counts. This helps the agent understand what information
-    is available through its tools.
-
-    Args:
-        memory_edit_timestamp: When memory blocks were last modified
-        timezone: The timezone to use for formatting timestamps (e.g., 'America/Los_Angeles')
-        previous_message_count: Number of messages in recall memory (conversation history)
-        archival_memory_size: Number of items in archival memory (long-term storage)
-
-    Returns:
-        A formatted string containing the memory metadata block with XML-style tags
-
-    Example Output:
-        <memory_metadata>
-        - The current time is: 2024-01-15 10:30 AM PST
-        - Memory blocks were last modified: 2024-01-15 09:00 AM PST
-        - 42 previous messages between you and the user are stored in recall memory (use tools to access them)
-        - 156 total memories you created are stored in archival memory (use tools to access them)
-        </memory_metadata>
-    """
-    # Put the timestamp in the local timezone (mimicking get_local_time())
-    timestamp_str = format_datetime(memory_edit_timestamp, timezone)
-
-    # Create a metadata block of info so the agent knows about the metadata of out-of-context memories
-    metadata_lines = [
-        "<memory_metadata>",
-        f"- The current time is: {get_local_time_fast(timezone)}",
-        f"- Memory blocks were last modified: {timestamp_str}",
-        f"- {previous_message_count} previous messages between you and the user are stored in recall memory (use tools to access them)",
-    ]
-
-    # Only include archival memory line if there are archival memories
-    if archival_memory_size is not None and archival_memory_size > 0:
-        metadata_lines.append(
-            f"- {archival_memory_size} total memories you created are stored in archival memory (use tools to access them)"
-        )
-
-    metadata_lines.append("</memory_metadata>")
-    memory_metadata_block = "\n".join(metadata_lines)
-    return memory_metadata_block
-
-
 class PreserveMapping(dict):
     """Used to preserve (do not modify) undefined variables in the system prompt"""
 
@@ -331,7 +278,7 @@ def compile_system_message(
         raise ValueError(f"Found protected variable '{IN_CONTEXT_MEMORY_KEYWORD}' in user-defined vars: {str(user_defined_variables)}")
     else:
         # TODO should this all put into the memory.__repr__ function?
-        memory_metadata_string = compile_memory_metadata_block(
+        memory_metadata_string = PromptGenerator.compile_memory_metadata_block(
             memory_edit_timestamp=in_context_memory_last_edit,
             previous_message_count=previous_message_count,
             archival_memory_size=archival_memory_size,
@@ -372,154 +319,6 @@ def compile_system_message(
     return formatted_prompt
 
 
-@trace_method
-def get_system_message_from_compiled_memory(
-    system_prompt: str,
-    memory_with_sources: str,
-    in_context_memory_last_edit: datetime,  # TODO move this inside of BaseMemory?
-    timezone: str,
-    user_defined_variables: Optional[dict] = None,
-    append_icm_if_missing: bool = True,
-    template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
-    previous_message_count: int = 0,
-    archival_memory_size: int = 0,
-) -> str:
-    """Prepare the final/full system message that will be fed into the LLM API
-
-    The base system message may be templated, in which case we need to render the variables.
-
-    The following are reserved variables:
-      - CORE_MEMORY: the in-context memory of the LLM
-    """
-    if user_defined_variables is not None:
-        # TODO eventually support the user defining their own variables to inject
-        raise NotImplementedError
-    else:
-        variables = {}
-
-    # Add the protected memory variable
-    if IN_CONTEXT_MEMORY_KEYWORD in variables:
-        raise ValueError(f"Found protected variable '{IN_CONTEXT_MEMORY_KEYWORD}' in user-defined vars: {str(user_defined_variables)}")
-    else:
-        # TODO should this all put into the memory.__repr__ function?
-        memory_metadata_string = compile_memory_metadata_block(
-            memory_edit_timestamp=in_context_memory_last_edit,
-            previous_message_count=previous_message_count,
-            archival_memory_size=archival_memory_size,
-            timezone=timezone,
-        )
-
-        full_memory_string = memory_with_sources + "\n\n" + memory_metadata_string
-
-        # Add to the variables list to inject
-        variables[IN_CONTEXT_MEMORY_KEYWORD] = full_memory_string
-
-    if template_format == "f-string":
-        memory_variable_string = "{" + IN_CONTEXT_MEMORY_KEYWORD + "}"
-
-        # Catch the special case where the system prompt is unformatted
-        if append_icm_if_missing:
-            if memory_variable_string not in system_prompt:
-                # In this case, append it to the end to make sure memory is still injected
-                # warnings.warn(f"{IN_CONTEXT_MEMORY_KEYWORD} variable was missing from system prompt, appending instead")
-                system_prompt += "\n\n" + memory_variable_string
-
-        # render the variables using the built-in templater
-        try:
-            if user_defined_variables:
-                formatted_prompt = safe_format(system_prompt, variables)
-            else:
-                formatted_prompt = system_prompt.replace(memory_variable_string, full_memory_string)
-        except Exception as e:
-            raise ValueError(f"Failed to format system prompt - {str(e)}. System prompt value:\n{system_prompt}")
-
-    else:
-        # TODO support for mustache and jinja2
-        raise NotImplementedError(template_format)
-
-    return formatted_prompt
-
-
-@trace_method
-async def compile_system_message_async(
-    system_prompt: str,
-    in_context_memory: Memory,
-    in_context_memory_last_edit: datetime,  # TODO move this inside of BaseMemory?
-    timezone: str,
-    user_defined_variables: Optional[dict] = None,
-    append_icm_if_missing: bool = True,
-    template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
-    previous_message_count: int = 0,
-    archival_memory_size: int = 0,
-    tool_rules_solver: Optional[ToolRulesSolver] = None,
-    sources: Optional[List] = None,
-    max_files_open: Optional[int] = None,
-) -> str:
-    """Prepare the final/full system message that will be fed into the LLM API
-
-    The base system message may be templated, in which case we need to render the variables.
-
-    The following are reserved variables:
-      - CORE_MEMORY: the in-context memory of the LLM
-    """
-
-    # Add tool rule constraints if available
-    tool_constraint_block = None
-    if tool_rules_solver is not None:
-        tool_constraint_block = tool_rules_solver.compile_tool_rule_prompts()
-
-    if user_defined_variables is not None:
-        # TODO eventually support the user defining their own variables to inject
-        raise NotImplementedError
-    else:
-        variables = {}
-
-    # Add the protected memory variable
-    if IN_CONTEXT_MEMORY_KEYWORD in variables:
-        raise ValueError(f"Found protected variable '{IN_CONTEXT_MEMORY_KEYWORD}' in user-defined vars: {str(user_defined_variables)}")
-    else:
-        # TODO should this all put into the memory.__repr__ function?
-        memory_metadata_string = compile_memory_metadata_block(
-            memory_edit_timestamp=in_context_memory_last_edit,
-            previous_message_count=previous_message_count,
-            archival_memory_size=archival_memory_size,
-            timezone=timezone,
-        )
-
-        memory_with_sources = await in_context_memory.compile_in_thread_async(
-            tool_usage_rules=tool_constraint_block, sources=sources, max_files_open=max_files_open
-        )
-        full_memory_string = memory_with_sources + "\n\n" + memory_metadata_string
-
-        # Add to the variables list to inject
-        variables[IN_CONTEXT_MEMORY_KEYWORD] = full_memory_string
-
-    if template_format == "f-string":
-        memory_variable_string = "{" + IN_CONTEXT_MEMORY_KEYWORD + "}"
-
-        # Catch the special case where the system prompt is unformatted
-        if append_icm_if_missing:
-            if memory_variable_string not in system_prompt:
-                # In this case, append it to the end to make sure memory is still injected
-                # warnings.warn(f"{IN_CONTEXT_MEMORY_KEYWORD} variable was missing from system prompt, appending instead")
-                system_prompt += "\n\n" + memory_variable_string
-
-        # render the variables using the built-in templater
-        try:
-            if user_defined_variables:
-                formatted_prompt = safe_format(system_prompt, variables)
-            else:
-                formatted_prompt = system_prompt.replace(memory_variable_string, full_memory_string)
-        except Exception as e:
-            raise ValueError(f"Failed to format system prompt - {str(e)}. System prompt value:\n{system_prompt}")
-
-    else:
-        # TODO support for mustache and jinja2
-        raise NotImplementedError(template_format)
-
-    return formatted_prompt
-
-
 @trace_method
 def initialize_message_sequence(
     agent_state: AgentState,
@@ -601,7 +400,7 @@ async def initialize_message_sequence_async(
     if memory_edit_timestamp is None:
         memory_edit_timestamp = get_local_time()
 
-    full_system_message = await compile_system_message_async(
+    full_system_message = await PromptGenerator.compile_system_message_async(
         system_prompt=agent_state.system,
         in_context_memory=agent_state.memory,
         in_context_memory_last_edit=memory_edit_timestamp,

letta/services/helpers/tool_parser_helper.py

@@ -70,13 +70,16 @@ def runtime_override_tool_json_schema(
     tool_list: list[JsonDict],
     response_format: ResponseFormatUnion | None,
     request_heartbeat: bool = True,
+    terminal_tools: set[str] | None = None,
 ) -> list[JsonDict]:
     """Override the tool JSON schemas at runtime if certain conditions are met.
 
     Cases:
         1. We will inject `send_message` tool calls with `response_format` if provided
-        2. Tools will have an additional `request_heartbeat` parameter added.
+        2. Tools will have an additional `request_heartbeat` parameter added (except for terminal tools).
     """
+    if terminal_tools is None:
+        terminal_tools = set()
     for tool_json in tool_list:
         if tool_json["name"] == SEND_MESSAGE_TOOL_NAME and response_format and response_format.type != ResponseFormatType.text:
             if response_format.type == ResponseFormatType.json_schema:
@@ -89,8 +92,8 @@ def runtime_override_tool_json_schema(
                     "properties": {},
                 }
         if request_heartbeat:
-            # TODO (cliandy): see support for tool control loop parameters
-            if tool_json["name"] != SEND_MESSAGE_TOOL_NAME:
+            # Only add request_heartbeat to non-terminal tools
+            if tool_json["name"] not in terminal_tools:
                 tool_json["parameters"]["properties"][REQUEST_HEARTBEAT_PARAM] = {
                     "type": "boolean",
                     "description": REQUEST_HEARTBEAT_DESCRIPTION,

letta/services/mcp/base_client.py

@@ -14,9 +14,15 @@ logger = get_logger(__name__)
 
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncBaseMCPClient:
-    def __init__(self, server_config: BaseServerConfig, oauth_provider: Optional[OAuthClientProvider] = None):
+    # HTTP headers
+    AGENT_ID_HEADER = "X-Agent-Id"
+
+    def __init__(
+        self, server_config: BaseServerConfig, oauth_provider: Optional[OAuthClientProvider] = None, agent_id: Optional[str] = None
+    ):
         self.server_config = server_config
         self.oauth_provider = oauth_provider
+        self.agent_id = agent_id
         self.exit_stack = AsyncExitStack()
         self.session: Optional[ClientSession] = None
         self.initialized = False

letta/services/mcp/sse_client.py

@@ -16,8 +16,10 @@ logger = get_logger(__name__)
 
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncSSEMCPClient(AsyncBaseMCPClient):
-    def __init__(self, server_config: SSEServerConfig, oauth_provider: Optional[OAuthClientProvider] = None):
-        super().__init__(server_config, oauth_provider)
+    def __init__(
+        self, server_config: SSEServerConfig, oauth_provider: Optional[OAuthClientProvider] = None, agent_id: Optional[str] = None
+    ):
+        super().__init__(server_config, oauth_provider, agent_id)
 
     async def _initialize_connection(self, server_config: SSEServerConfig) -> None:
         headers = {}
@@ -27,6 +29,9 @@ class AsyncSSEMCPClient(AsyncBaseMCPClient):
         if server_config.auth_header and server_config.auth_token:
             headers[server_config.auth_header] = server_config.auth_token
 
+        if self.agent_id:
+            headers[self.AGENT_ID_HEADER] = self.agent_id
+
         # Use OAuth provider if available, otherwise use regular headers
         if self.oauth_provider:
             sse_cm = sse_client(url=server_config.server_url, headers=headers if headers else None, auth=self.oauth_provider)

letta/services/mcp/stdio_client.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
@@ -10,6 +12,9 @@ logger = get_logger(__name__)
 
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncStdioMCPClient(AsyncBaseMCPClient):
+    def __init__(self, server_config: StdioServerConfig, oauth_provider=None, agent_id: Optional[str] = None):
+        super().__init__(server_config, oauth_provider, agent_id)
+
     async def _initialize_connection(self, server_config: StdioServerConfig) -> None:
         args = [arg.split() for arg in server_config.args]
         # flatten

letta/services/mcp/streamable_http_client.py

@@ -12,8 +12,13 @@ logger = get_logger(__name__)
 
 
 class AsyncStreamableHTTPMCPClient(AsyncBaseMCPClient):
-    def __init__(self, server_config: StreamableHTTPServerConfig, oauth_provider: Optional[OAuthClientProvider] = None):
-        super().__init__(server_config, oauth_provider)
+    def __init__(
+        self,
+        server_config: StreamableHTTPServerConfig,
+        oauth_provider: Optional[OAuthClientProvider] = None,
+        agent_id: Optional[str] = None,
+    ):
+        super().__init__(server_config, oauth_provider, agent_id)
 
     async def _initialize_connection(self, server_config: BaseServerConfig) -> None:
         if not isinstance(server_config, StreamableHTTPServerConfig):
@@ -28,6 +33,10 @@ class AsyncStreamableHTTPMCPClient(AsyncBaseMCPClient):
             if server_config.auth_header and server_config.auth_token:
                 headers[server_config.auth_header] = server_config.auth_token
 
+            # Add agent ID header if provided
+            if self.agent_id:
+                headers[self.AGENT_ID_HEADER] = self.agent_id
+
             # Use OAuth provider if available, otherwise use regular headers
             if self.oauth_provider:
                 streamable_http_cm = streamablehttp_client(

letta/services/mcp_manager.py

@@ -41,6 +41,7 @@ from letta.services.mcp.sse_client import MCP_CONFIG_TOPLEVEL_KEY, AsyncSSEMCPCl
 from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.services.tool_manager import ToolManager
+from letta.settings import tool_settings
 from letta.utils import enforce_types, printd
 
 logger = get_logger(__name__)
@@ -55,19 +56,18 @@ class MCPManager:
         self.cached_mcp_servers = {}  # maps id -> async connection
 
     @enforce_types
-    async def list_mcp_server_tools(self, mcp_server_name: str, actor: PydanticUser) -> List[MCPTool]:
+    async def list_mcp_server_tools(self, mcp_server_name: str, actor: PydanticUser, agent_id: Optional[str] = None) -> List[MCPTool]:
         """Get a list of all tools for a specific MCP server."""
         mcp_client = None
         try:
             mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
             mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
             server_config = mcp_config.to_config()
-            mcp_client = await self.get_mcp_client(server_config, actor)
+            mcp_client = await self.get_mcp_client(server_config, actor, agent_id=agent_id)
             await mcp_client.connect_to_server()
 
             # list tools
             tools = await mcp_client.list_tools()
-
             # Add health information to each tool
             for tool in tools:
                 if tool.inputSchema:
@@ -92,33 +92,34 @@ class MCPManager:
         tool_args: Optional[Dict[str, Any]],
         environment_variables: Dict[str, str],
         actor: PydanticUser,
+        agent_id: Optional[str] = None,
     ) -> Tuple[str, bool]:
         """Call a specific tool from a specific MCP server."""
-        from letta.settings import tool_settings
-
-        if not tool_settings.mcp_read_from_config:
-            # read from DB
-            mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
-            mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
-            server_config = mcp_config.to_config(environment_variables)
-        else:
-            # read from config file
-            mcp_config = self.read_mcp_config()
-            if mcp_server_name not in mcp_config:
-                raise ValueError(f"MCP server {mcp_server_name} not found in config.")
-            server_config = mcp_config[mcp_server_name]
-
-        mcp_client = await self.get_mcp_client(server_config, actor)
-        await mcp_client.connect_to_server()
-
-        # call tool
-        result, success = await mcp_client.execute_tool(tool_name, tool_args)
-        logger.info(f"MCP Result: {result}, Success: {success}")
-        # TODO: change to pydantic tool
+        mcp_client = None
+        try:
+            if not tool_settings.mcp_read_from_config:
+                # read from DB
+                mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
+                mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
+                server_config = mcp_config.to_config(environment_variables)
+            else:
+                # read from config file
+                mcp_config = self.read_mcp_config()
+                if mcp_server_name not in mcp_config:
+                    raise ValueError(f"MCP server {mcp_server_name} not found in config.")
+                server_config = mcp_config[mcp_server_name]
 
-        await mcp_client.cleanup()
+            mcp_client = await self.get_mcp_client(server_config, actor, agent_id=agent_id)
+            await mcp_client.connect_to_server()
 
-        return result, success
+            # call tool
+            result, success = await mcp_client.execute_tool(tool_name, tool_args)
+            logger.info(f"MCP Result: {result}, Success: {success}")
+            # TODO: change to pydantic tool
+            return result, success
+        finally:
+            if mcp_client:
+                await mcp_client.cleanup()
 
     @enforce_types
     async def add_tool_from_mcp_server(self, mcp_server_name: str, mcp_tool_name: str, actor: PydanticUser) -> PydanticTool:
@@ -129,7 +130,6 @@ class MCPManager:
             raise ValueError(f"MCP server '{mcp_server_name}' not found")
 
         mcp_tools = await self.list_mcp_server_tools(mcp_server_name, actor=actor)
-
         for mcp_tool in mcp_tools:
             # TODO: @jnjpng move health check to tool class
             if mcp_tool.name == mcp_tool_name:
@@ -450,6 +450,7 @@ class MCPManager:
         server_config: Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig],
         actor: PydanticUser,
         oauth_provider: Optional[Any] = None,
+        agent_id: Optional[str] = None,
     ) -> Union[AsyncSSEMCPClient, AsyncStdioMCPClient, AsyncStreamableHTTPMCPClient]:
         """
         Helper function to create the appropriate MCP client based on server configuration.
@@ -482,13 +483,13 @@ class MCPManager:
 
         if server_config.type == MCPServerType.SSE:
             server_config = SSEServerConfig(**server_config.model_dump())
-            return AsyncSSEMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+            return AsyncSSEMCPClient(server_config=server_config, oauth_provider=oauth_provider, agent_id=agent_id)
         elif server_config.type == MCPServerType.STDIO:
             server_config = StdioServerConfig(**server_config.model_dump())
-            return AsyncStdioMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+            return AsyncStdioMCPClient(server_config=server_config, oauth_provider=oauth_provider, agent_id=agent_id)
         elif server_config.type == MCPServerType.STREAMABLE_HTTP:
             server_config = StreamableHTTPServerConfig(**server_config.model_dump())
-            return AsyncStreamableHTTPMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+            return AsyncStreamableHTTPMCPClient(server_config=server_config, oauth_provider=oauth_provider, agent_id=agent_id)
         else:
             raise ValueError(f"Unsupported server config type: {type(server_config)}")
 

letta/services/source_manager.py

@@ -143,7 +143,6 @@ class SourceManager:
                     update_dict[col.name] = excluded[col.name]
 
         upsert_stmt = stmt.on_conflict_do_update(index_elements=["name", "organization_id"], set_=update_dict)
-
         await session.execute(upsert_stmt)
         await session.commit()
 
@@ -397,3 +396,29 @@ class SourceManager:
             sources_orm = result.scalars().all()
 
             return [source.to_pydantic() for source in sources_orm]
+
+    @enforce_types
+    @trace_method
+    async def get_existing_source_names(self, source_names: List[str], actor: PydanticUser) -> set[str]:
+        """
+        Fast batch check to see which source names already exist for the organization.
+
+        Args:
+            source_names: List of source names to check
+            actor: User performing the action
+
+        Returns:
+            Set of source names that already exist
+        """
+        if not source_names:
+            return set()
+
+        async with db_registry.async_session() as session:
+            query = select(SourceModel.name).where(
+                SourceModel.name.in_(source_names), SourceModel.organization_id == actor.organization_id, SourceModel.is_deleted == False
+            )
+
+            result = await session.execute(query)
+            existing_names = result.scalars().all()
+
+            return set(existing_names)

letta/services/summarizer/summarizer.py

@@ -15,6 +15,8 @@ from letta.schemas.letta_message_content import TextContent
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.message_manager import MessageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.system import package_summarize_message_no_counts
 from letta.templates.template_helper import render_template
@@ -36,6 +38,10 @@ class Summarizer:
         message_buffer_limit: int = 10,
         message_buffer_min: int = 3,
         partial_evict_summarizer_percentage: float = 0.30,
+        agent_manager: Optional[AgentManager] = None,
+        message_manager: Optional[MessageManager] = None,
+        actor: Optional[User] = None,
+        agent_id: Optional[str] = None,
     ):
         self.mode = mode
 
@@ -46,6 +52,12 @@ class Summarizer:
         self.summarizer_agent = summarizer_agent
         self.partial_evict_summarizer_percentage = partial_evict_summarizer_percentage
 
+        # for partial buffer only
+        self.agent_manager = agent_manager
+        self.message_manager = message_manager
+        self.actor = actor
+        self.agent_id = agent_id
+
     @trace_method
     async def summarize(
         self,
@@ -121,9 +133,6 @@ class Summarizer:
             logger.debug("Not forcing summarization, returning in-context messages as is.")
             return all_in_context_messages, False
 
-        # Very ugly code to pull LLMConfig etc from the SummarizerAgent if we're not using it for anything else
-        assert self.summarizer_agent is not None
-
         # First step: determine how many messages to retain
         total_message_count = len(all_in_context_messages)
         assert self.partial_evict_summarizer_percentage >= 0.0 and self.partial_evict_summarizer_percentage <= 1.0
@@ -147,15 +156,13 @@ class Summarizer:
 
         # Dynamically get the LLMConfig from the summarizer agent
         # Pretty cringe code here that we need the agent for this but we don't use it
-        agent_state = await self.summarizer_agent.agent_manager.get_agent_by_id_async(
-            agent_id=self.summarizer_agent.agent_id, actor=self.summarizer_agent.actor
-        )
+        agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=self.agent_id, actor=self.actor)
 
         # TODO if we do this via the "agent", then we can more easily allow toggling on the memory block version
         summary_message_str = await simple_summary(
             messages=messages_to_summarize,
             llm_config=agent_state.llm_config,
-            actor=self.summarizer_agent.actor,
+            actor=self.actor,
             include_ack=True,
         )
 
@@ -185,9 +192,9 @@ class Summarizer:
         )[0]
 
         # Create the message in the DB
-        await self.summarizer_agent.message_manager.create_many_messages_async(
+        await self.message_manager.create_many_messages_async(
             pydantic_msgs=[summary_message_obj],
-            actor=self.summarizer_agent.actor,
+            actor=self.actor,
         )
 
         updated_in_context_messages = all_in_context_messages[assistant_message_index:]
@@ -354,7 +361,11 @@ async def simple_summary(messages: List[Message], llm_config: LLMConfig, actor:
     # NOTE: we should disable the inner_thoughts_in_kwargs here, because we don't use it
     # I'm leaving it commented it out for now for safety but is fine assuming the var here is a copy not a reference
     # llm_config.put_inner_thoughts_in_kwargs = False
-    response_data = await llm_client.request_async(request_data, llm_config)
+    try:
+        response_data = await llm_client.request_async(request_data, llm_config)
+    except Exception as e:
+        # handle LLM error (likely a context window exceeded error)
+        raise llm_client.handle_llm_error(e)
     response = llm_client.convert_response_to_chat_completion(response_data, input_messages_obj, llm_config)
     if response.choices[0].message.content is None:
         logger.warning("No content returned from summarizer")

letta/services/tool_executor/files_tool_executor.py

@@ -151,16 +151,16 @@ class LettaFileToolExecutor(ToolExecutor):
             offset = file_request.offset
             length = file_request.length
 
-            # Convert 1-indexed offset/length to 0-indexed start/end for LineChunker
+            # Use 0-indexed offset/length directly 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 offset is not None and offset < 0:
+                    raise ValueError(f"Offset for file {file_name} must be >= 0 (0-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
+                # Use offset directly as it's already 0-indexed
+                start = offset if offset is not None else None
                 if start is not None and length is not None:
                     end = start + length
                 else:
@@ -193,7 +193,7 @@ class LettaFileToolExecutor(ToolExecutor):
                 visible_content=visible_content,
                 max_files_open=agent_state.max_files_open,
                 start_line=start + 1 if start is not None else None,  # convert to 1-indexed for user display
-                end_line=end if end is not None else None,  # end is already exclusive in slicing, so this is correct
+                end_line=end if end is not None else None,  # end is already exclusive, shows as 1-indexed inclusive
             )
 
             opened_files.append(file_name)
@@ -220,10 +220,14 @@ class LettaFileToolExecutor(ToolExecutor):
         for req in file_requests:
             previous_info = format_previous_range(req.file_name)
             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}){previous_info}")
+                # Display as 1-indexed for user readability: (offset+1) to (offset+length)
+                start_line = req.offset + 1
+                end_line = req.offset + req.length
+                file_summaries.append(f"{req.file_name} (lines {start_line}-{end_line}){previous_info}")
             elif req.offset is not None:
-                file_summaries.append(f"{req.file_name} (lines {req.offset}-end){previous_info}")
+                # Display as 1-indexed
+                start_line = req.offset + 1
+                file_summaries.append(f"{req.file_name} (lines {start_line}-end){previous_info}")
             else:
                 file_summaries.append(f"{req.file_name}{previous_info}")