letta-nightly 0.8.5.dev20250624104340__py3-none-any.whl → 0.8.6.dev20250625222533__py3-none-any.whl

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

@@ -13,7 +13,7 @@ from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
-from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, LETTA_MODEL_ENDPOINT
 from letta.groups.sleeptime_multi_agent_v2 import SleeptimeMultiAgentV2
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns
 from letta.log import get_logger
@@ -25,7 +25,7 @@ from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.group import Group
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion, MessageType
-from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
+from letta.schemas.letta_request import LettaAsyncRequest, LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
 from letta.schemas.message import MessageCreate
@@ -323,17 +323,7 @@ async def attach_source(
     agent_state = await server.agent_manager.attach_missing_files_tools_async(agent_state=agent_state, actor=actor)
 
     files = await server.file_manager.list_files(source_id, actor, include_content=True)
-    texts = []
-    file_ids = []
-    file_names = []
-    for f in files:
-        texts.append(f.content if f.content else "")
-        file_ids.append(f.id)
-        file_names.append(f.file_name)
-
-    await server.insert_files_into_context_window(
-        agent_state=agent_state, texts=texts, file_ids=file_ids, file_names=file_names, actor=actor
-    )
+    await server.insert_files_into_context_window(agent_state=agent_state, file_metadata_with_content=files, actor=actor)
 
     if agent_state.enable_sleeptime:
         source = await server.source_manager.get_source_by_id(source_id=source_id)
@@ -686,7 +676,7 @@ async def send_message(
     # TODO: This is redundant, remove soon
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex", "bedrock"]
 
     if agent_eligible and model_compatible:
         if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
@@ -707,6 +697,7 @@ async def send_message(
                 message_manager=server.message_manager,
                 agent_manager=server.agent_manager,
                 block_manager=server.block_manager,
+                job_manager=server.job_manager,
                 passage_manager=server.passage_manager,
                 actor=actor,
                 step_manager=server.step_manager,
@@ -768,9 +759,9 @@ async def send_message_streaming(
     # TODO: This is redundant, remove soon
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
-    model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
-    not_letta_endpoint = not ("inference.letta.com" in agent.llm_config.model_endpoint)
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex", "bedrock"]
+    model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "bedrock"]
+    not_letta_endpoint = LETTA_MODEL_ENDPOINT != agent.llm_config.model_endpoint
 
     if agent_eligible and model_compatible:
         if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
@@ -793,6 +784,7 @@ async def send_message_streaming(
                 message_manager=server.message_manager,
                 agent_manager=server.agent_manager,
                 block_manager=server.block_manager,
+                job_manager=server.job_manager,
                 passage_manager=server.passage_manager,
                 actor=actor,
                 step_manager=server.step_manager,
@@ -857,7 +849,14 @@ async def process_message_background(
     try:
         agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
         agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
-        model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+        model_compatible = agent.llm_config.model_endpoint_type in [
+            "anthropic",
+            "openai",
+            "together",
+            "google_ai",
+            "google_vertex",
+            "bedrock",
+        ]
         if agent_eligible and model_compatible:
             if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
                 agent_loop = SleeptimeMultiAgentV2(
@@ -877,6 +876,7 @@ async def process_message_background(
                     message_manager=server.message_manager,
                     agent_manager=server.agent_manager,
                     block_manager=server.block_manager,
+                    job_manager=server.job_manager,
                     passage_manager=server.passage_manager,
                     actor=actor,
                     step_manager=server.step_manager,
@@ -886,6 +886,7 @@ async def process_message_background(
             result = await agent_loop.step(
                 messages,
                 max_steps=max_steps,
+                run_id=job_id,
                 use_assistant_message=use_assistant_message,
                 request_start_timestamp_ns=request_start_timestamp_ns,
                 include_return_message_types=include_return_message_types,
@@ -897,6 +898,7 @@ async def process_message_background(
                 input_messages=messages,
                 stream_steps=False,
                 stream_tokens=False,
+                metadata={"job_id": job_id},
                 # Support for AssistantMessage
                 use_assistant_message=use_assistant_message,
                 assistant_message_tool_name=assistant_message_tool_name,
@@ -929,9 +931,8 @@ async def process_message_background(
 async def send_message_async(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
-    request: LettaRequest = Body(...),
+    request: LettaAsyncRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    callback_url: Optional[str] = Query(None, description="Optional callback URL to POST to when the job completes"),
 ):
     """
     Asynchronously process a user message and return a run object.
@@ -944,7 +945,7 @@ async def send_message_async(
     run = Run(
         user_id=actor.id,
         status=JobStatus.created,
-        callback_url=callback_url,
+        callback_url=request.callback_url,
         metadata={
             "job_type": "send_message_async",
             "agent_id": agent_id,
@@ -953,6 +954,7 @@ async def send_message_async(
             use_assistant_message=request.use_assistant_message,
             assistant_message_tool_name=request.assistant_message_tool_name,
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+            include_return_message_types=request.include_return_message_types,
         ),
     )
     run = await server.job_manager.create_job_async(pydantic_job=run, actor=actor)
@@ -1021,7 +1023,7 @@ async def summarize_agent_conversation(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex", "bedrock"]
 
     if agent_eligible and model_compatible:
         agent = LettaAgent(
@@ -1029,6 +1031,7 @@ async def summarize_agent_conversation(
             message_manager=server.message_manager,
             agent_manager=server.agent_manager,
             block_manager=server.block_manager,
+            job_manager=server.job_manager,
             passage_manager=server.passage_manager,
             actor=actor,
             step_manager=server.step_manager,

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

@@ -3,9 +3,8 @@ from typing import Annotated, List, Optional
 from fastapi import APIRouter, Depends, Header, HTTPException, Query
 from pydantic import Field
 
-from letta.orm.enums import JobType
 from letta.orm.errors import NoResultFound
-from letta.schemas.enums import JobStatus, MessageRole
+from letta.schemas.enums import JobStatus, JobType, MessageRole
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
@@ -92,7 +91,7 @@ async def list_run_messages(
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
     order: str = Query(
-        "desc", description="Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order."
+        "asc", description="Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order."
     ),
     role: Optional[MessageRole] = Query(None, description="Filter by role"),
 ):

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

@@ -304,6 +304,37 @@ async def list_source_files(
     )
 
 
+@router.get("/{source_id}/files/{file_id}", response_model=FileMetadata, operation_id="get_file_metadata")
+async def get_file_metadata(
+    source_id: str,
+    file_id: str,
+    include_content: bool = Query(False, description="Whether to include full file content"),
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Retrieve metadata for a specific file by its ID.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+    # Verify the source exists and user has access
+    source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    if not source:
+        raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
+
+    # Get file metadata using the file manager
+    file_metadata = await server.file_manager.get_file_by_id(file_id=file_id, actor=actor, include_content=include_content)
+
+    if not file_metadata:
+        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
+
+    # Verify the file belongs to the specified source
+    if file_metadata.source_id != source_id:
+        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
+
+    return file_metadata
+
+
 # it's redundant to include /delete in the URL path. The HTTP verb DELETE already implies that action.
 # it's still good practice to return a status indicating the success or failure of the deletion
 @router.delete("/{source_id}/{file_id}", status_code=204, operation_id="delete_file_from_source")

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

@@ -51,6 +51,7 @@ async def create_voice_chat_completions(
         message_manager=server.message_manager,
         agent_manager=server.agent_manager,
         block_manager=server.block_manager,
+        job_manager=server.job_manager,
         passage_manager=server.passage_manager,
         actor=actor,
     )

letta/server/rest_api/utils.py

@@ -13,7 +13,13 @@ from openai.types.chat.chat_completion_message_tool_call import Function as Open
 from openai.types.chat.completion_create_params import CompletionCreateParams
 from pydantic import BaseModel
 
-from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
+from letta.constants import (
+    DEFAULT_MESSAGE_TOOL,
+    DEFAULT_MESSAGE_TOOL_KWARG,
+    FUNC_FAILED_HEARTBEAT_MESSAGE,
+    REQ_HEARTBEAT_MESSAGE,
+    REQUEST_HEARTBEAT_PARAM,
+)
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.helpers.datetime_helpers import get_utc_time, get_utc_timestamp_ns, ns_to_ms
 from letta.helpers.message_helper import convert_message_creates_to_messages
@@ -169,7 +175,7 @@ def log_error_to_sentry(e):
         sentry_sdk.capture_exception(e)
 
 
-def create_input_messages(input_messages: List[MessageCreate], agent_id: str, actor: User) -> List[Message]:
+def create_input_messages(input_messages: List[MessageCreate], agent_id: str, timezone: str, actor: User) -> List[Message]:
     """
     Converts a user input message into the internal structured format.
 
@@ -177,7 +183,7 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ac
     we should unify this when it's clear what message attributes we need.
     """
 
-    messages = convert_message_creates_to_messages(input_messages, agent_id, wrap_user_message=False, wrap_system_message=False)
+    messages = convert_message_creates_to_messages(input_messages, agent_id, timezone, wrap_user_message=False, wrap_system_message=False)
     for message in messages:
         message.organization_id = actor.organization_id
     return messages
@@ -192,17 +198,19 @@ def create_letta_messages_from_llm_response(
     tool_call_id: str,
     function_call_success: bool,
     function_response: Optional[str],
+    timezone: str,
     actor: User,
-    add_heartbeat_request_system_message: bool = False,
+    continue_stepping: bool = False,
+    heartbeat_reason: Optional[str] = None,
     reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
     llm_batch_item_id: Optional[str] = None,
     step_id: str | None = None,
 ) -> List[Message]:
     messages = []
-
     # Construct the tool call with the assistant's message
-    function_arguments["request_heartbeat"] = True
+    # Force set request_heartbeat in tool_args to calculated continue_stepping
+    function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
     tool_call = OpenAIToolCall(
         id=tool_call_id,
         function=OpenAIFunction(
@@ -232,7 +240,7 @@ def create_letta_messages_from_llm_response(
     # TODO: This helps preserve ordering
     tool_message = Message(
         role=MessageRole.tool,
-        content=[TextContent(text=package_function_response(function_call_success, function_response))],
+        content=[TextContent(text=package_function_response(function_call_success, function_response, timezone))],
         organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
@@ -252,9 +260,14 @@ def create_letta_messages_from_llm_response(
     )
     messages.append(tool_message)
 
-    if add_heartbeat_request_system_message:
+    if continue_stepping:
         heartbeat_system_message = create_heartbeat_system_message(
-            agent_id=agent_id, model=model, function_call_success=function_call_success, actor=actor, llm_batch_item_id=llm_batch_item_id
+            agent_id=agent_id,
+            model=model,
+            function_call_success=function_call_success,
+            actor=actor,
+            timezone=timezone,
+            heartbeat_reason=heartbeat_reason,
         )
         messages.append(heartbeat_system_message)
 
@@ -265,12 +278,22 @@ def create_letta_messages_from_llm_response(
 
 
 def create_heartbeat_system_message(
-    agent_id: str, model: str, function_call_success: bool, actor: User, llm_batch_item_id: Optional[str] = None
+    agent_id: str,
+    model: str,
+    function_call_success: bool,
+    timezone: str,
+    actor: User,
+    llm_batch_item_id: Optional[str] = None,
+    heartbeat_reason: Optional[str] = None,
 ) -> Message:
-    text_content = REQ_HEARTBEAT_MESSAGE if function_call_success else FUNC_FAILED_HEARTBEAT_MESSAGE
+    if heartbeat_reason:
+        text_content = heartbeat_reason
+    else:
+        text_content = REQ_HEARTBEAT_MESSAGE if function_call_success else FUNC_FAILED_HEARTBEAT_MESSAGE
+
     heartbeat_system_message = Message(
         role=MessageRole.user,
-        content=[TextContent(text=get_heartbeat(text_content))],
+        content=[TextContent(text=get_heartbeat(timezone, text_content))],
         organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
@@ -287,6 +310,7 @@ def create_assistant_messages_from_openai_response(
     agent_id: str,
     model: str,
     actor: User,
+    timezone: str,
 ) -> List[Message]:
     """
     Converts an OpenAI response into Messages that follow the internal
@@ -303,8 +327,9 @@ def create_assistant_messages_from_openai_response(
         tool_call_id=tool_call_id,
         function_call_success=True,
         function_response=None,
+        timezone=timezone,
         actor=actor,
-        add_heartbeat_request_system_message=False,
+        continue_stepping=False,
     )
 
 

letta/server/server.py

@@ -43,6 +43,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 # openai schemas
 from letta.schemas.enums import JobStatus, MessageStreamStatus, ProviderCategory, ProviderType
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
+from letta.schemas.file import FileMetadata
 from letta.schemas.group import GroupCreate, ManagerType, SleeptimeManager, VoiceSleeptimeManager
 from letta.schemas.job import Job, JobUpdate
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, MessageType, ToolReturnMessage
@@ -54,9 +55,9 @@ from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySumm
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.providers import (
-    AnthropicBedrockProvider,
     AnthropicProvider,
     AzureProvider,
+    BedrockProvider,
     DeepSeekProvider,
     GoogleAIProvider,
     GoogleVertexProvider,
@@ -82,6 +83,7 @@ from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.file_manager import FileManager
+from letta.services.file_processor.chunker.line_chunker import LineChunker
 from letta.services.files_agents_manager import FileAgentManager
 from letta.services.group_manager import GroupManager
 from letta.services.helpers.tool_execution_helper import prepare_local_sandbox
@@ -365,11 +367,11 @@ class SyncServer(Server):
                     base_url=model_settings.vllm_api_base,
                 )
             )
-        if model_settings.aws_access_key and model_settings.aws_secret_access_key and model_settings.aws_region:
+        if model_settings.aws_access_key_id and model_settings.aws_secret_access_key and model_settings.aws_default_region:
             self._enabled_providers.append(
-                AnthropicBedrockProvider(
+                BedrockProvider(
                     name="bedrock",
-                    aws_region=model_settings.aws_region,
+                    region=model_settings.aws_default_region,
                 )
             )
         # Attempt to enable LM Studio by default
@@ -631,7 +633,7 @@ class SyncServer(Server):
 
             packaged_user_message = system.package_user_message(
                 user_message=message,
-                time=timestamp.isoformat() if timestamp else None,
+                timezone=agent.timezone,
             )
 
             # NOTE: eventually deprecate and only allow passing Message types
@@ -710,6 +712,7 @@ class SyncServer(Server):
         # Run the agent state forward
         return self._step(actor=actor, agent_id=agent_id, input_messages=message)
 
+    # TODO: Deprecate this
     def send_messages(
         self,
         actor: User,
@@ -826,8 +829,6 @@ class SyncServer(Server):
         self,
         request: CreateAgent,
         actor: User,
-        # interface
-        interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         if request.llm_config is None:
             if request.model is None:
@@ -867,6 +868,16 @@ class SyncServer(Server):
         )
         log_event(name="end create_agent db")
 
+        log_event(name="start insert_files_into_context_window db")
+        if request.source_ids:
+            for source_id in request.source_ids:
+                files = await self.file_manager.list_files(source_id, actor, include_content=True)
+                await self.insert_files_into_context_window(agent_state=main_agent, file_metadata_with_content=files, actor=actor)
+
+            main_agent = await self.agent_manager.refresh_file_blocks(agent_state=main_agent, actor=actor)
+            main_agent = await self.agent_manager.attach_missing_files_tools_async(agent_state=main_agent, actor=actor)
+        log_event(name="end insert_files_into_context_window db")
+
         if request.enable_sleeptime:
             if request.agent_type == AgentType.voice_convo_agent:
                 main_agent = await self.create_voice_sleeptime_agent_async(main_agent=main_agent, actor=actor)
@@ -1355,6 +1366,7 @@ class SyncServer(Server):
             message_manager=self.message_manager,
             agent_manager=self.agent_manager,
             block_manager=self.block_manager,
+            job_manager=self.job_manager,
             passage_manager=self.passage_manager,
             actor=actor,
             step_manager=self.step_manager,
@@ -1369,13 +1381,25 @@ class SyncServer(Server):
             )
         await self.agent_manager.delete_agent_async(agent_id=sleeptime_agent_state.id, actor=actor)
 
-    async def _upsert_file_to_agent(self, agent_id: str, text: str, file_id: str, file_name: str, actor: User) -> None:
+    async def _upsert_file_to_agent(self, agent_id: str, file_metadata_with_content: FileMetadata, actor: User) -> List[str]:
         """
         Internal method to create or update a file <-> agent association
+
+        Returns:
+            List of file names that were closed due to LRU eviction
         """
-        await self.file_agent_manager.attach_file(
-            agent_id=agent_id, file_id=file_id, file_name=file_name, actor=actor, visible_content=text
+        # TODO: Maybe have LineChunker object be on the server level?
+        content_lines = LineChunker().chunk_text(file_metadata=file_metadata_with_content)
+        visible_content = "\n".join(content_lines)
+
+        file_agent, closed_files = await self.file_agent_manager.attach_file(
+            agent_id=agent_id,
+            file_id=file_metadata_with_content.id,
+            file_name=file_metadata_with_content.file_name,
+            actor=actor,
+            visible_content=visible_content,
         )
+        return closed_files
 
     async def _remove_file_from_agent(self, agent_id: str, file_id: str, actor: User) -> None:
         """
@@ -1391,7 +1415,7 @@ class SyncServer(Server):
             logger.info(f"File {file_id} already removed from agent {agent_id}, skipping...")
 
     async def insert_file_into_context_windows(
-        self, source_id: str, text: str, file_id: str, file_name: str, actor: User, agent_states: Optional[List[AgentState]] = None
+        self, source_id: str, file_metadata_with_content: FileMetadata, actor: User, agent_states: Optional[List[AgentState]] = None
     ) -> List[AgentState]:
         """
         Insert the uploaded document into the context window of all agents
@@ -1406,12 +1430,19 @@ class SyncServer(Server):
         logger.info(f"Inserting document into context window for source: {source_id}")
         logger.info(f"Attached agents: {[a.id for a in agent_states]}")
 
-        await asyncio.gather(*(self._upsert_file_to_agent(agent_state.id, text, file_id, file_name, actor) for agent_state in agent_states))
+        # Collect any files that were closed due to LRU eviction during bulk attach
+        all_closed_files = await asyncio.gather(
+            *(self._upsert_file_to_agent(agent_state.id, file_metadata_with_content, actor) for agent_state in agent_states)
+        )
+        # Flatten and log if any files were closed
+        closed_files = [file for closed_list in all_closed_files for file in closed_list]
+        if closed_files:
+            logger.info(f"LRU eviction closed {len(closed_files)} files during bulk attach: {closed_files}")
 
         return agent_states
 
     async def insert_files_into_context_window(
-        self, agent_state: AgentState, texts: List[str], file_ids: List[str], file_names: List[str], actor: User
+        self, agent_state: AgentState, file_metadata_with_content: List[FileMetadata], actor: User
     ) -> None:
         """
         Insert the uploaded documents into the context window of an agent
@@ -1419,15 +1450,14 @@ class SyncServer(Server):
         """
         logger.info(f"Inserting documents into context window for agent_state: {agent_state.id}")
 
-        if len(texts) != len(file_ids):
-            raise ValueError(f"Mismatch between number of texts ({len(texts)}) and file ids ({len(file_ids)})")
-
-        await asyncio.gather(
-            *(
-                self._upsert_file_to_agent(agent_state.id, text, file_id, file_name, actor)
-                for text, file_id, file_name in zip(texts, file_ids, file_names)
-            )
+        # Collect any files that were closed due to LRU eviction during bulk insert
+        all_closed_files = await asyncio.gather(
+            *(self._upsert_file_to_agent(agent_state.id, file_metadata, actor) for file_metadata in file_metadata_with_content)
         )
+        # Flatten and log if any files were closed
+        closed_files = [file for closed_list in all_closed_files for file in closed_list]
+        if closed_files:
+            logger.info(f"LRU eviction closed {len(closed_files)} files during bulk insert: {closed_files}")
 
     async def remove_file_from_context_windows(self, source_id: str, file_id: str, actor: User) -> None:
         """
@@ -1996,6 +2026,7 @@ class SyncServer(Server):
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
+                job_manager=self.job_manager,
                 passage_manager=self.passage_manager,
                 actor=actor,
                 sandbox_env_vars=tool_env_vars,