Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: convert many methods to async (#2193)
cthomas65e32082f766
diff --git a/letta/agents/helpers.py b/letta/agents/helpers.pyindex 17d9e6762..5578d1fb6 100644--- a/letta/agents/helpers.py+++ b/letta/agents/helpers.py@@ -92,8 +92,7 @@ async def _prepare_in_context_messages_async(current_in_context_messages = await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor)# Create a new user message from the input and store it- # TODO: make this async- new_in_context_messages = message_manager.create_many_messages(+ new_in_context_messages = await message_manager.create_many_messages_async(create_input_messages(input_messages=input_messages, agent_id=agent_state.id, actor=actor), actor=actor)diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.pyindex 62e6dfe04..1010540dd 100644--- a/letta/agents/letta_agent.py+++ b/letta/agents/letta_agent.py@@ -58,7 +58,7 @@ class LettaAgent(BaseAgent):self.passage_manager = passage_managerself.response_messages: List[Message] = []- self.last_function_response = self._load_last_function_response()+ self.last_function_response = None# Cached archival memory/message sizeself.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)@@ -237,6 +237,8 @@ class LettaAgent(BaseAgent):]# Mirror the sync agent loop: get allowed tools or allow all if none are allowed+ if self.last_function_response is None:+ self.last_function_response = await self._load_last_function_response_async()valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]),last_function_response=self.last_function_response,@@ -330,7 +332,7 @@ class LettaAgent(BaseAgent):pre_computed_assistant_message_id=pre_computed_assistant_message_id,pre_computed_tool_message_id=pre_computed_tool_message_id,)- persisted_messages = self.message_manager.create_many_messages(tool_call_messages, actor=self.actor)+ persisted_messages = await self.message_manager.create_many_messages_async(tool_call_messages, actor=self.actor)self.last_function_response = function_responsereturn persisted_messages, continue_stepping@@ -416,9 +418,9 @@ class LettaAgent(BaseAgent):results = await asyncio.gather(*tasks)return results- def _load_last_function_response(self):+ async def _load_last_function_response_async(self):"""Load the last function response from message history"""- in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_id, actor=self.actor)+ in_context_messages = await self.agent_manager.get_in_context_messages_async(agent_id=self.agent_id, actor=self.actor)for msg in reversed(in_context_messages):if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and isinstance(msg.content[0], TextContent):text_content = msg.content[0].textdiff --git a/letta/agents/letta_agent_batch.py b/letta/agents/letta_agent_batch.pyindex f844876e6..201cd565b 100644--- a/letta/agents/letta_agent_batch.py+++ b/letta/agents/letta_agent_batch.py@@ -196,7 +196,7 @@ class LettaAgentBatch(BaseAgent):)log_event(name="persist_llm_batch_job")- llm_batch_job = self.batch_manager.create_llm_batch_job(+ llm_batch_job = await self.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic, # TODO: Expand to more providerscreate_batch_response=batch_response,actor=self.actor,@@ -214,7 +214,7 @@ class LettaAgentBatch(BaseAgent):if batch_items:log_event(name="bulk_create_batch_items")- batch_items_persisted = self.batch_manager.create_llm_batch_items_bulk(batch_items, actor=self.actor)+ batch_items_persisted = await self.batch_manager.create_llm_batch_items_bulk_async(batch_items, actor=self.actor)log_event(name="return_batch_response")return LettaBatchResponse(@@ -229,7 +229,7 @@ class LettaAgentBatch(BaseAgent):@trace_methodasync def resume_step_after_request(self, letta_batch_id: str, llm_batch_id: str) -> LettaBatchResponse:log_event(name="load_context")- llm_batch_job = self.batch_manager.get_llm_batch_job_by_id(llm_batch_id=llm_batch_id, actor=self.actor)+ llm_batch_job = await self.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=llm_batch_id, actor=self.actor)ctx = await self._collect_resume_context(llm_batch_id)log_event(name="update_statuses")@@ -239,7 +239,7 @@ class LettaAgentBatch(BaseAgent):exec_results = await self._execute_tools(ctx)log_event(name="persist_messages")- msg_map = self._persist_tool_messages(exec_results, ctx)+ msg_map = await self._persist_tool_messages(exec_results, ctx)log_event(name="mark_steps_done")self._mark_steps_complete(llm_batch_id, ctx.agent_ids)@@ -266,7 +266,7 @@ class LettaAgentBatch(BaseAgent):@trace_methodasync def _collect_resume_context(self, llm_batch_id: str) -> _ResumeContext:# NOTE: We only continue for items with successful results- batch_items = self.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_id, request_status=JobStatus.completed)+ batch_items = await self.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_id, request_status=JobStatus.completed)agent_ids, agent_state_map = [], {}provider_results, name_map, args_map, cont_map = {}, {}, {}, {}@@ -386,7 +386,7 @@ class LettaAgentBatch(BaseAgent):return result- def _persist_tool_messages(+ async def _persist_tool_messages(self,exec_results: Sequence[Tuple[str, Tuple[str, bool]]],ctx: _ResumeContext,@@ -408,7 +408,7 @@ class LettaAgentBatch(BaseAgent):)msg_map[aid] = msgs# flatten & persist- self.message_manager.create_many_messages([m for msgs in msg_map.values() for m in msgs], actor=self.actor)+ await self.message_manager.create_many_messages_async([m for msgs in msg_map.values() for m in msgs], actor=self.actor)return msg_mapdef _mark_steps_complete(self, llm_batch_id: str, agent_ids: List[str]) -> None:diff --git a/letta/client/client.py b/letta/client/client.pyindex 14fdc0091..802ca451e 100644--- a/letta/client/client.py+++ b/letta/client/client.py@@ -1,3 +1,4 @@+import asyncioimport loggingimport sysimport time@@ -3055,7 +3056,21 @@ class LocalClient(AbstractClient):Returns:tools (List[Tool]): List of tools"""- return self.server.tool_manager.list_tools(after=after, limit=limit, actor=self.user)+ # Get the current event loop or create a new one if there isn't one+ try:+ loop = asyncio.get_event_loop()+ if loop.is_running():+ # We're in an async context but can't await - use a new loop via run_coroutine_threadsafe+ concurrent_future = asyncio.run_coroutine_threadsafe(+ self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit), loop+ )+ return concurrent_future.result()+ else:+ # We have a loop but it's not running - we can just run the coroutine+ return loop.run_until_complete(self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit))+ except RuntimeError:+ # No running event loop - create a new one with asyncio.run+ return asyncio.run(self.server.tool_manager.list_tools_async(actor=self.user, after=after, limit=limit))def get_tool(self, id: str) -> Optional[Tool]:"""diff --git a/letta/jobs/llm_batch_job_polling.py b/letta/jobs/llm_batch_job_polling.pyindex a12274758..e0f51dd54 100644--- a/letta/jobs/llm_batch_job_polling.py+++ b/letta/jobs/llm_batch_job_polling.py@@ -180,7 +180,7 @@ async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchRespotry:# 1. Retrieve running batch jobs- batches = server.batch_manager.list_running_llm_batches()+ batches = await server.batch_manager.list_running_llm_batches_async()metrics.total_batches = len(batches)# TODO: Expand to more providers@@ -220,7 +220,11 @@ async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchRespo)# launch them all at once- tasks = [_resume(server.batch_manager.get_llm_batch_job_by_id(bid)) for bid, *_ in completed]+ async def get_and_resume(batch_id):+ batch = await server.batch_manager.get_llm_batch_job_by_id_async(batch_id)+ return await _resume(batch)++ tasks = [get_and_resume(bid) for bid, *_ in completed]new_batch_responses = await asyncio.gather(*tasks, return_exceptions=True)return new_batch_responsesdiff --git a/letta/orm/sqlalchemy_base.py b/letta/orm/sqlalchemy_base.pyindex 2e5abe99a..dda47c6cf 100644--- a/letta/orm/sqlalchemy_base.py+++ b/letta/orm/sqlalchemy_base.py@@ -631,6 +631,24 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):except (DBAPIError, IntegrityError) as e:self._handle_dbapi_error(e)+ @handle_db_timeout+ async def create_async(self, db_session: "AsyncSession", actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":+ """Async version of create function"""+ logger.debug(f"Creating {self.__class__.__name__} with ID: {self.id} with actor={actor}")++ if actor:+ self._set_created_and_updated_by_fields(actor.id)+ try:+ db_session.add(self)+ if no_commit:+ await db_session.flush() # no commit, just flush to get PK+ else:+ await db_session.commit()+ await db_session.refresh(self)+ return self+ except (DBAPIError, IntegrityError) as e:+ self._handle_dbapi_error(e)+@classmethod@handle_db_timeoutdef batch_create(cls, items: List["SqlalchemyBase"], db_session: "Session", actor: Optional["User"] = None) -> List["SqlalchemyBase"]:@@ -672,6 +690,51 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):except (DBAPIError, IntegrityError) as e:cls._handle_dbapi_error(e)+ @classmethod+ @handle_db_timeout+ async def batch_create_async(+ cls, items: List["SqlalchemyBase"], db_session: "AsyncSession", actor: Optional["User"] = None+ ) -> List["SqlalchemyBase"]:+ """+ Async version of batch_create method.+ Create multiple records in a single transaction for better performance.+ Args:+ items: List of model instances to create+ db_session: AsyncSession session+ actor: Optional user performing the action+ Returns:+ List of created model instances+ """+ logger.debug(f"Async batch creating {len(items)} {cls.__name__} items with actor={actor}")+ if not items:+ return []++ # Set created/updated by fields if actor is provided+ if actor:+ for item in items:+ item._set_created_and_updated_by_fields(actor.id)++ try:+ async with db_session as session:+ session.add_all(items)+ await session.flush() # Flush to generate IDs but don't commit yet++ # Collect IDs to fetch the complete objects after commit+ item_ids = [item.id for item in items]++ await session.commit()++ # Re-query the objects to get them with relationships loaded+ query = select(cls).where(cls.id.in_(item_ids))+ if hasattr(cls, "created_at"):+ query = query.order_by(cls.created_at)++ result = await session.execute(query)+ return list(result.scalars())++ except (DBAPIError, IntegrityError) as e:+ cls._handle_dbapi_error(e)+@handle_db_timeoutdef delete(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")diff --git a/letta/server/rest_api/routers/v1/tools.py b/letta/server/rest_api/routers/v1/tools.pyindex a1c7591b9..8c9aeac0b 100644--- a/letta/server/rest_api/routers/v1/tools.py+++ b/letta/server/rest_api/routers/v1/tools.py@@ -76,7 +76,7 @@ def retrieve_tool(@router.get("/", response_model=List[Tool], operation_id="list_tools")-def list_tools(+async def list_tools(after: Optional[str] = None,limit: Optional[int] = 50,name: Optional[str] = None,@@ -89,9 +89,9 @@ def list_tools(try:actor = server.user_manager.get_user_or_default(user_id=actor_id)if name is not None:- tool = server.tool_manager.get_tool_by_name(tool_name=name, actor=actor)+ tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)return [tool] if tool else []- return server.tool_manager.list_tools(actor=actor, after=after, limit=limit)+ return await server.tool_manager.list_tools_async(actor=actor, after=after, limit=limit)except Exception as e:# Log or print the full exception here for debuggingprint(f"Error occurred: {e}")diff --git a/letta/services/agent_manager.py b/letta/services/agent_manager.pyindex 9747ea606..54bb454c1 100644--- a/letta/services/agent_manager.py+++ b/letta/services/agent_manager.py@@ -791,6 +791,11 @@ class AgentManager:message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_idsreturn self.message_manager.get_messages_by_ids(message_ids=message_ids, actor=actor)+ @enforce_types+ async def get_in_context_messages_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticMessage]:+ message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids+ return await self.message_manager.get_messages_by_ids_async(message_ids=message_ids, actor=actor)+@enforce_typesdef get_system_message(self, agent_id: str, actor: PydanticUser) -> PydanticMessage:message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_idsdiff --git a/letta/services/job_manager.py b/letta/services/job_manager.pyindex 74576d4d6..d92c817b8 100644--- a/letta/services/job_manager.py+++ b/letta/services/job_manager.py@@ -44,6 +44,19 @@ class JobManager:job.create(session, actor=actor) # Save job in the databasereturn job.to_pydantic()+ @enforce_types+ async def create_job_async(+ self, pydantic_job: Union[PydanticJob, PydanticRun, PydanticBatchJob], actor: PydanticUser+ ) -> Union[PydanticJob, PydanticRun, PydanticBatchJob]:+ """Create a new job based on the JobCreate schema."""+ async with db_registry.async_session() as session:+ # Associate the job with the user+ pydantic_job.user_id = actor.id+ job_data = pydantic_job.model_dump(to_orm=True)+ job = JobModel(**job_data)+ await job.create_async(session, actor=actor) # Save job in the database+ return job.to_pydantic()+@enforce_typesdef update_job_by_id(self, job_id: str, job_update: JobUpdate, actor: PydanticUser) -> PydanticJob:"""Update a job by its ID with the given JobUpdate object."""diff --git a/letta/services/llm_batch_manager.py b/letta/services/llm_batch_manager.pyindex 7d7b4b543..052e2bbe2 100644--- a/letta/services/llm_batch_manager.py+++ b/letta/services/llm_batch_manager.py@@ -2,7 +2,7 @@ import datetimefrom typing import Any, Dict, List, Optional, Tuplefrom anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse-from sqlalchemy import desc, func, tuple_+from sqlalchemy import desc, func, select, tuple_from letta.jobs.types import BatchPollingResult, ItemUpdateInfo, RequestStatusUpdateInfo, StepStatusUpdateInfofrom letta.log import get_logger@@ -26,7 +26,7 @@ class LLMBatchManager:"""Manager for handling both LLMBatchJob and LLMBatchItem operations."""@enforce_types- def create_llm_batch_job(+ async def create_llm_batch_job_async(self,llm_provider: ProviderType,create_batch_response: BetaMessageBatch,@@ -35,7 +35,7 @@ class LLMBatchManager:status: JobStatus = JobStatus.created,) -> PydanticLLMBatchJob:"""Create a new LLM batch job."""- with db_registry.session() as session:+ async with db_registry.async_session() as session:batch = LLMBatchJob(status=status,llm_provider=llm_provider,@@ -43,14 +43,14 @@ class LLMBatchManager:organization_id=actor.organization_id,letta_batch_job_id=letta_batch_job_id,)- batch.create(session, actor=actor)+ await batch.create_async(session, actor=actor)return batch.to_pydantic()@enforce_types- def get_llm_batch_job_by_id(self, llm_batch_id: str, actor: Optional[PydanticUser] = None) -> PydanticLLMBatchJob:+ async def get_llm_batch_job_by_id_async(self, llm_batch_id: str, actor: Optional[PydanticUser] = None) -> PydanticLLMBatchJob:"""Retrieve a single batch job by ID."""- with db_registry.session() as session:- batch = LLMBatchJob.read(db_session=session, identifier=llm_batch_id, actor=actor)+ async with db_registry.async_session() as session:+ batch = await LLMBatchJob.read_async(db_session=session, identifier=llm_batch_id, actor=actor)return batch.to_pydantic()@enforce_types@@ -197,16 +197,16 @@ class LLMBatchManager:return [message.to_pydantic() for message in results]@enforce_types- def list_running_llm_batches(self, actor: Optional[PydanticUser] = None) -> List[PydanticLLMBatchJob]:+ async def list_running_llm_batches_async(self, actor: Optional[PydanticUser] = None) -> List[PydanticLLMBatchJob]:"""Return all running LLM batch jobs, optionally filtered by actor's organization."""- with db_registry.session() as session:- query = session.query(LLMBatchJob).filter(LLMBatchJob.status == JobStatus.running)+ async with db_registry.async_session() as session:+ query = select(LLMBatchJob).where(LLMBatchJob.status == JobStatus.running)if actor is not None:- query = query.filter(LLMBatchJob.organization_id == actor.organization_id)+ query = query.where(LLMBatchJob.organization_id == actor.organization_id)- results = query.all()- return [batch.to_pydantic() for batch in results]+ results = await session.execute(query)+ return [batch.to_pydantic() for batch in results.scalars().all()]@enforce_typesdef create_llm_batch_item(@@ -234,7 +234,9 @@ class LLMBatchManager:return item.to_pydantic()@enforce_types- def create_llm_batch_items_bulk(self, llm_batch_items: List[PydanticLLMBatchItem], actor: PydanticUser) -> List[PydanticLLMBatchItem]:+ async def create_llm_batch_items_bulk_async(+ self, llm_batch_items: List[PydanticLLMBatchItem], actor: PydanticUser+ ) -> List[PydanticLLMBatchItem]:"""Create multiple batch items in bulk for better performance.@@ -245,7 +247,7 @@ class LLMBatchManager:Returns:List of created batch items as Pydantic models"""- with db_registry.session() as session:+ async with db_registry.async_session() as session:# Convert Pydantic models to ORM objectsorm_items = []for item in llm_batch_items:@@ -261,8 +263,7 @@ class LLMBatchManager:)orm_items.append(orm_item)- # Use the batch_create method to create all items at once- created_items = LLMBatchItem.batch_create(orm_items, session, actor=actor)+ created_items = await LLMBatchItem.batch_create_async(orm_items, session, actor=actor)# Convert back to Pydantic modelsreturn [item.to_pydantic() for item in created_items]@@ -300,7 +301,7 @@ class LLMBatchManager:return item.update(db_session=session, actor=actor).to_pydantic()@enforce_types- def list_llm_batch_items(+ async def list_llm_batch_items_async(self,llm_batch_id: str,limit: Optional[int] = None,@@ -321,29 +322,29 @@ class LLMBatchManager:The results are ordered by their id in ascending order."""- with db_registry.session() as session:- query = session.query(LLMBatchItem).filter(LLMBatchItem.llm_batch_id == llm_batch_id)+ async with db_registry.async_session() as session:+ query = select(LLMBatchItem).where(LLMBatchItem.llm_batch_id == llm_batch_id)if actor is not None:- query = query.filter(LLMBatchItem.organization_id == actor.organization_id)+ query = query.where(LLMBatchItem.organization_id == actor.organization_id)# Additional optional filtersif agent_id is not None:- query = query.filter(LLMBatchItem.agent_id == agent_id)+ query = query.where(LLMBatchItem.agent_id == agent_id)if request_status is not None:- query = query.filter(LLMBatchItem.request_status == request_status)+ query = query.where(LLMBatchItem.request_status == request_status)if step_status is not None:- query = query.filter(LLMBatchItem.step_status == step_status)+ query = query.where(LLMBatchItem.step_status == step_status)if after is not None:- query = query.filter(LLMBatchItem.id > after)+ query = query.where(LLMBatchItem.id > after)query = query.order_by(LLMBatchItem.id.asc())if limit is not None:query = query.limit(limit)- results = query.all()- return [item.to_pydantic() for item in results]+ results = await session.execute(query)+ return [item.to_pydantic() for item in results.scalars()]def bulk_update_llm_batch_items(self, llm_batch_id_agent_id_pairs: List[Tuple[str, str]], field_updates: List[Dict[str, Any]], strict: bool = Truediff --git a/letta/services/message_manager.py b/letta/services/message_manager.pyindex 0dda1cfe6..95666fec6 100644--- a/letta/services/message_manager.py+++ b/letta/services/message_manager.py@@ -71,6 +71,16 @@ class MessageManager:msg.create(session, actor=actor) # Persist to databasereturn msg.to_pydantic()+ def _create_many_preprocess(self, pydantic_msgs: List[PydanticMessage], actor: PydanticUser) -> List[MessageModel]:+ # Create ORM model instances for all messages+ orm_messages = []+ for pydantic_msg in pydantic_msgs:+ # Set the organization id of the Pydantic message+ pydantic_msg.organization_id = actor.organization_id+ msg_data = pydantic_msg.model_dump(to_orm=True)+ orm_messages.append(MessageModel(**msg_data))+ return orm_messages+@enforce_typesdef create_many_messages(self, pydantic_msgs: List[PydanticMessage], actor: PydanticUser) -> List[PydanticMessage]:"""@@ -83,23 +93,32 @@ class MessageManager:Returns:List of created Pydantic message models"""-if not pydantic_msgs:return []- # Create ORM model instances for all messages- orm_messages = []- for pydantic_msg in pydantic_msgs:- # Set the organization id of the Pydantic message- pydantic_msg.organization_id = actor.organization_id- msg_data = pydantic_msg.model_dump(to_orm=True)- orm_messages.append(MessageModel(**msg_data))-- # Use the batch_create method for efficient creation+ orm_messages = self._create_many_preprocess(pydantic_msgs, actor)with db_registry.session() as session:created_messages = MessageModel.batch_create(orm_messages, session, actor=actor)+ return [msg.to_pydantic() for msg in created_messages]++ @enforce_types+ async def create_many_messages_async(self, pydantic_msgs: List[PydanticMessage], actor: PydanticUser) -> List[PydanticMessage]:+ """+ Create multiple messages in a single database transaction asynchronously.++ Args:+ pydantic_msgs: List of Pydantic message models to create+ actor: User performing the action++ Returns:+ List of created Pydantic message models+ """+ if not pydantic_msgs:+ return []- # Convert back to Pydantic models+ orm_messages = self._create_many_preprocess(pydantic_msgs, actor)+ async with db_registry.async_session() as session:+ created_messages = await MessageModel.batch_create_async(orm_messages, session, actor=actor)return [msg.to_pydantic() for msg in created_messages]@enforce_typesdiff --git a/letta/services/tool_manager.py b/letta/services/tool_manager.pyindex 5b0cff898..eebff5ea7 100644--- a/letta/services/tool_manager.py+++ b/letta/services/tool_manager.py@@ -115,6 +115,16 @@ class ToolManager:except NoResultFound:return None+ @enforce_types+ async def get_tool_by_name_async(self, tool_name: str, actor: PydanticUser) -> Optional[PydanticTool]:+ """Retrieve a tool by its name and a user. We derive the organization from the user, and retrieve that tool."""+ try:+ async with db_registry.async_session() as session:+ tool = await ToolModel.read_async(db_session=session, name=tool_name, actor=actor)+ return tool.to_pydantic()+ except NoResultFound:+ return None+@enforce_typesdef get_tool_id_by_name(self, tool_name: str, actor: PydanticUser) -> Optional[str]:"""Retrieve a tool by its name and a user. We derive the organization from the user, and retrieve that tool."""@@ -126,10 +136,10 @@ class ToolManager:return None@enforce_types- def list_tools(self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:+ async def list_tools_async(self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:"""List all tools with optional pagination."""- with db_registry.session() as session:- tools = ToolModel.list(+ async with db_registry.async_session() as session:+ tools = await ToolModel.list_async(db_session=session,after=after,limit=limit,diff --git a/poetry.lock b/poetry.lockindex c6402e438..6d001a9c8 100644--- a/poetry.lock+++ b/poetry.lock@@ -5533,19 +5533,19 @@ dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments[[package]]name = "pytest-asyncio"-version = "0.23.8"+version = "0.24.0"description = "Pytest support for asyncio"optional = truepython-versions = ">=3.8"groups = ["main"]markers = "extra == \"dev\" or extra == \"all\""files = [- {file = "pytest_asyncio-0.23.8-py3-none-any.whl", hash = "sha256:50265d892689a5faefb84df80819d1ecef566eb3549cf915dfb33569359d1ce2"},- {file = "pytest_asyncio-0.23.8.tar.gz", hash = "sha256:759b10b33a6dc61cce40a8bd5205e302978bbbcc00e279a8b61d9a6a3c82e4d3"},+ {file = "pytest_asyncio-0.24.0-py3-none-any.whl", hash = "sha256:a811296ed596b69bf0b6f3dc40f83bcaf341b155a269052d82efa2b25ac7037b"},+ {file = "pytest_asyncio-0.24.0.tar.gz", hash = "sha256:d081d828e576d85f875399194281e92bf8a68d60d72d1a2faf2feddb6c46b276"},][package.dependencies]-pytest = ">=7.0.0,<9"+pytest = ">=8.2,<9"[package.extras]docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"]@@ -7570,4 +7570,4 @@ tests = ["wikipedia"][metadata]lock-version = "2.1"python-versions = "<3.14,>=3.10"-content-hash = "7322eb70314d3f078fda8cf9b580d416f13663b399d4b0f6a9e0c4a8914808b5"+content-hash = "19eee9b3cd3d270cb748183bc332dd69706bb0bd3150c62e73e61ed437a40c78"diff --git a/pyproject.toml b/pyproject.tomlindex 778848546..0abde6b5c 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -47,7 +47,7 @@ autoflake = {version = "^2.3.0", optional = true}python-multipart = "^0.0.19"sqlalchemy-utils = "^0.41.2"pytest-order = {version = "^1.2.0", optional = true}-pytest-asyncio = {version = "^0.23.2", optional = true}+pytest-asyncio = {version = "^0.24.0", optional = true}pydantic-settings = "^2.2.1"httpx-sse = "^0.4.0"isort = { version = "^5.13.2", optional = true }diff --git a/tests/integration_test_batch_api_cron_jobs.py b/tests/integration_test_batch_api_cron_jobs.pyindex 39306568f..4479b0dd1 100644--- a/tests/integration_test_batch_api_cron_jobs.py+++ b/tests/integration_test_batch_api_cron_jobs.py@@ -174,16 +174,16 @@ def create_test_agent(name, actor, test_id: Optional[str] = None, model="anthropreturn agent_manager.create_agent(agent_create=agent_create, actor=actor, _test_only_force_id=test_id)-def create_test_letta_batch_job(server, default_user):+async def create_test_letta_batch_job_async(server, default_user):"""Create a test batch job with the given batch response."""- return server.job_manager.create_job(BatchJob(user_id=default_user.id), actor=default_user)+ return await server.job_manager.create_job_async(BatchJob(user_id=default_user.id), actor=default_user)-def create_test_llm_batch_job(server, batch_response, default_user):+async def create_test_llm_batch_job_async(server, batch_response, default_user):"""Create a test batch job with the given batch response."""- letta_batch_job = create_test_letta_batch_job(server, default_user)+ letta_batch_job = await create_test_letta_batch_job_async(server, default_user)- return server.batch_manager.create_llm_batch_job(+ return await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=batch_response,actor=default_user,@@ -262,7 +262,7 @@ def mock_anthropic_client(server, batch_a_resp, batch_b_resp, agent_b_id, agent_# -----------------------------# End-to-End Test# -----------------------------[email protected](loop_scope="session")async def test_polling_simple_real_batch(client, default_user, server):# --- Step 1: Prepare test data ---# Create batch responses with different statuses@@ -276,7 +276,7 @@ async def test_polling_simple_real_batch(client, default_user, server):agent_c = create_test_agent("agent_c", default_user, test_id="agent-6156f470-a09d-4d51-aa62-7114e0971d56")# --- Step 2: Create batch jobs ---- job_a = create_test_llm_batch_job(server, batch_a_resp, default_user)+ job_a = await create_test_llm_batch_job_async(server, batch_a_resp, default_user)# --- Step 3: Create batch items ---item_a = create_test_batch_item(server, job_a.id, agent_a.id, default_user)@@ -293,7 +293,7 @@ async def test_polling_simple_real_batch(client, default_user, server):await poll_running_llm_batches(server)# --- Step 5: Verify batch job status updates ---- updated_job_a = server.batch_manager.get_llm_batch_job_by_id(llm_batch_id=job_a.id, actor=default_user)+ updated_job_a = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=job_a.id, actor=default_user)assert updated_job_a.status == JobStatus.completed@@ -403,7 +403,7 @@ async def test_polling_simple_real_batch(client, default_user, server):)[email protected](loop_scope="session")async def test_polling_mixed_batch_jobs(client, default_user, server):"""End-to-end test for polling batch jobs with mixed statuses and idempotency.@@ -433,8 +433,8 @@ async def test_polling_mixed_batch_jobs(client, default_user, server):agent_c = create_test_agent("agent_c", default_user)# --- Step 2: Create batch jobs ---- job_a = create_test_llm_batch_job(server, batch_a_resp, default_user)- job_b = create_test_llm_batch_job(server, batch_b_resp, default_user)+ job_a = await create_test_llm_batch_job_async(server, batch_a_resp, default_user)+ job_b = await create_test_llm_batch_job_async(server, batch_b_resp, default_user)# --- Step 3: Create batch items ---item_a = create_test_batch_item(server, job_a.id, agent_a.id, default_user)@@ -449,8 +449,8 @@ async def test_polling_mixed_batch_jobs(client, default_user, server):await poll_running_llm_batches(server)# --- Step 6: Verify batch job status updates ---- updated_job_a = server.batch_manager.get_llm_batch_job_by_id(llm_batch_id=job_a.id, actor=default_user)- updated_job_b = server.batch_manager.get_llm_batch_job_by_id(llm_batch_id=job_b.id, actor=default_user)+ updated_job_a = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=job_a.id, actor=default_user)+ updated_job_b = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=job_b.id, actor=default_user)# Job A should remain running since its processing_status is "in_progress"assert updated_job_a.status == JobStatus.running@@ -498,8 +498,8 @@ async def test_polling_mixed_batch_jobs(client, default_user, server):# --- Step 9: Verify that nothing changed for completed jobs ---# Refresh all objects- final_job_a = server.batch_manager.get_llm_batch_job_by_id(llm_batch_id=job_a.id, actor=default_user)- final_job_b = server.batch_manager.get_llm_batch_job_by_id(llm_batch_id=job_b.id, actor=default_user)+ final_job_a = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=job_a.id, actor=default_user)+ final_job_b = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_id=job_b.id, actor=default_user)final_item_a = server.batch_manager.get_llm_batch_item_by_id(item_a.id, actor=default_user)final_item_b = server.batch_manager.get_llm_batch_item_by_id(item_b.id, actor=default_user)final_item_c = server.batch_manager.get_llm_batch_item_by_id(item_c.id, actor=default_user)diff --git a/tests/integration_test_voice_agent.py b/tests/integration_test_voice_agent.pyindex 6ace4640f..65bc54947 100644--- a/tests/integration_test_voice_agent.py+++ b/tests/integration_test_voice_agent.py@@ -268,7 +268,7 @@ def _assert_valid_chunk(chunk, idx, chunks):# --- Tests --- #[email protected](loop_scope="session")@pytest.mark.parametrize("model", ["openai/gpt-4o-mini", "anthropic/claude-3-5-sonnet-20241022"])async def test_model_compatibility(disable_e2b_api_key, client, model, server, group_id, actor):request = _get_chat_request("How are you?")@@ -303,7 +303,7 @@ async def test_model_compatibility(disable_e2b_api_key, client, model, server, gprint(chunk.choices[0].delta.content)[email protected](loop_scope="session")@pytest.mark.parametrize("message", ["Use search memory tool to recall what my name is."])@pytest.mark.parametrize("endpoint", ["v1/voice-beta"])async def test_voice_recall_memory(disable_e2b_api_key, client, voice_agent, message, endpoint):@@ -318,7 +318,7 @@ async def test_voice_recall_memory(disable_e2b_api_key, client, voice_agent, mesprint(chunk.choices[0].delta.content)[email protected](loop_scope="session")@pytest.mark.parametrize("endpoint", ["v1/voice-beta"])async def test_trigger_summarization(disable_e2b_api_key, client, server, voice_agent, group_id, endpoint, actor):server.group_manager.modify_group(@@ -350,7 +350,7 @@ async def test_trigger_summarization(disable_e2b_api_key, client, server, voice_print(chunk.choices[0].delta.content)[email protected](loop_scope="session")async def test_summarization(disable_e2b_api_key, voice_agent):agent_manager = AgentManager()user_manager = UserManager()@@ -422,16 +422,17 @@ async def test_summarization(disable_e2b_api_key, voice_agent):summarizer.fire_and_forget.assert_called_once()[email protected](loop_scope="session")async def test_voice_sleeptime_agent(disable_e2b_api_key, client, voice_agent):"""Tests chat completion streaming using the Async OpenAI client."""agent_manager = AgentManager()+ tool_manager = ToolManager()user_manager = UserManager()actor = user_manager.get_default_user()- finish_rethinking_memory_tool = client.tools.list(name="finish_rethinking_memory")[0]- store_memories_tool = client.tools.list(name="store_memories")[0]- rethink_user_memory_tool = client.tools.list(name="rethink_user_memory")[0]+ finish_rethinking_memory_tool = tool_manager.get_tool_by_name(tool_name="finish_rethinking_memory", actor=actor)+ store_memories_tool = tool_manager.get_tool_by_name(tool_name="store_memories", actor=actor)+ rethink_user_memory_tool = tool_manager.get_tool_by_name(tool_name="rethink_user_memory", actor=actor)request = CreateAgent(name=voice_agent.name + "-sleeptime",agent_type=AgentType.voice_sleeptime_agent,@@ -487,7 +488,7 @@ async def test_voice_sleeptime_agent(disable_e2b_api_key, client, voice_agent):assert not missing, f"Did not see calls to: {', '.join(missing)}"[email protected](loop_scope="session")async def test_init_voice_convo_agent(voice_agent, server, actor):assert voice_agent.enable_sleeptime == Truediff --git a/tests/test_letta_agent_batch.py b/tests/test_letta_agent_batch.pyindex b043b216e..11da3a197 100644--- a/tests/test_letta_agent_batch.py+++ b/tests/test_letta_agent_batch.py@@ -1,4 +1,3 @@-import asyncioimport osimport threadingfrom datetime import datetime, timezone@@ -165,14 +164,6 @@ def step_state_map(agents):return {agent.id: AgentStepState(step_number=0, tool_rules_solver=solver) for agent in agents}[email protected](scope="session")-def event_loop(request):- """Create an instance of the default event loop for each test case."""- loop = asyncio.get_event_loop_policy().new_event_loop()- yield loop- loop.close()--def create_batch_response(batch_id: str, processing_status: str = "in_progress") -> BetaMessageBatch:"""Create a dummy BetaMessageBatch with the specified ID and status."""now = datetime(2024, 8, 20, 18, 37, 24, 100435, tzinfo=timezone.utc)@@ -377,7 +368,7 @@ class MockAsyncIterable:# --------------------------------------------------------------------------- #[email protected](loop_scope="session")async def test_rethink_tool_modify_agent_state(client, disable_e2b_api_key, server, default_user, batch_job, rethink_tool):target_block_label = "human"new_memory = "banana"@@ -459,9 +450,9 @@ async def test_rethink_tool_modify_agent_state(client, disable_e2b_api_key, servassert block.value == new_memory[email protected](loop_scope="session")async def test_partial_error_from_anthropic_batch(- disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job, event_loop+ disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job):anthropic_batch_id = "msgbatch_test_12345"dummy_batch_response = create_batch_response(@@ -518,13 +509,13 @@ async def test_partial_error_from_anthropic_batch(new_batch_responses = await poll_running_llm_batches(server)# Verify database records were updated correctly- llm_batch_job = server.batch_manager.get_llm_batch_job_by_id(llm_batch_job.id, actor=default_user)+ llm_batch_job = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_job.id, actor=default_user)# Verify job propertiesassert llm_batch_job.status == JobStatus.completed, "Job status should be 'completed'"# Verify batch items- items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(items) == 3, f"Expected 3 batch items, got {len(items)}"# Verify only one new batch response@@ -542,7 +533,7 @@ async def test_partial_error_from_anthropic_batch(assert post_resume_response.agent_count == 2# New batch‑items should exist, initialised in (created, paused) state- new_items = server.batch_manager.list_llm_batch_items(+ new_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=post_resume_response.last_llm_batch_id, actor=default_user)assert len(new_items) == 2, f"Expected 2 new batch item, got {len(new_items)}"@@ -563,7 +554,7 @@ async def test_partial_error_from_anthropic_batch(# Old items must have been flipped to completed / finished earlier# (sanity – we already asserted this above, but we keep it close for clarity)- old_items = server.batch_manager.list_llm_batch_items(+ old_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=pre_resume_response.last_llm_batch_id, actor=default_user)for item in old_items:@@ -619,9 +610,9 @@ async def test_partial_error_from_anthropic_batch(assert agent_messages[0].role == MessageRole.user, "Expected initial user message"[email protected](loop_scope="session")async def test_resume_step_some_stop(- disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job, event_loop+ disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job):anthropic_batch_id = "msgbatch_test_12345"dummy_batch_response = create_batch_response(@@ -680,13 +671,13 @@ async def test_resume_step_some_stop(new_batch_responses = await poll_running_llm_batches(server)# Verify database records were updated correctly- llm_batch_job = server.batch_manager.get_llm_batch_job_by_id(llm_batch_job.id, actor=default_user)+ llm_batch_job = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_job.id, actor=default_user)# Verify job propertiesassert llm_batch_job.status == JobStatus.completed, "Job status should be 'completed'"# Verify batch items- items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(items) == 3, f"Expected 3 batch items, got {len(items)}"assert all([item.request_status == JobStatus.completed for item in items])@@ -705,7 +696,7 @@ async def test_resume_step_some_stop(assert post_resume_response.agent_count == 1# New batch‑items should exist, initialised in (created, paused) state- new_items = server.batch_manager.list_llm_batch_items(+ new_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=post_resume_response.last_llm_batch_id, actor=default_user)assert len(new_items) == 1, f"Expected 1 new batch item, got {len(new_items)}"@@ -726,7 +717,7 @@ async def test_resume_step_some_stop(# Old items must have been flipped to completed / finished earlier# (sanity – we already asserted this above, but we keep it close for clarity)- old_items = server.batch_manager.list_llm_batch_items(+ old_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=pre_resume_response.last_llm_batch_id, actor=default_user)assert {i.request_status for i in old_items} == {JobStatus.completed}@@ -782,9 +773,9 @@ def _assert_descending_order(messages):return True[email protected](loop_scope="session")async def test_resume_step_after_request_all_continue(- disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job, event_loop+ disable_e2b_api_key, server, default_user, agents: Tuple[AgentState], batch_requests, step_state_map, batch_job):anthropic_batch_id = "msgbatch_test_12345"dummy_batch_response = create_batch_response(@@ -818,7 +809,7 @@ async def test_resume_step_after_request_all_continue(assert len(llm_batch_jobs) == 1, f"Expected 1 llm_batch_jobs, got {len(llm_batch_jobs)}"llm_batch_job = llm_batch_jobs[0]- llm_batch_items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ llm_batch_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(llm_batch_items) == 3, f"Expected 3 llm_batch_items, got {len(llm_batch_items)}"# 2. Invoke the polling job and mock responses from Anthropic@@ -840,13 +831,13 @@ async def test_resume_step_after_request_all_continue(new_batch_responses = await poll_running_llm_batches(server)# Verify database records were updated correctly- llm_batch_job = server.batch_manager.get_llm_batch_job_by_id(llm_batch_job.id, actor=default_user)+ llm_batch_job = await server.batch_manager.get_llm_batch_job_by_id_async(llm_batch_job.id, actor=default_user)# Verify job propertiesassert llm_batch_job.status == JobStatus.completed, "Job status should be 'completed'"# Verify batch items- items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(items) == 3, f"Expected 3 batch items, got {len(items)}"assert all([item.request_status == JobStatus.completed for item in items])@@ -864,7 +855,7 @@ async def test_resume_step_after_request_all_continue(assert post_resume_response.agent_count == 3# New batch‑items should exist, initialised in (created, paused) state- new_items = server.batch_manager.list_llm_batch_items(+ new_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=post_resume_response.last_llm_batch_id, actor=default_user)assert len(new_items) == 3, f"Expected 3 new batch items, got {len(new_items)}"@@ -883,7 +874,7 @@ async def test_resume_step_after_request_all_continue(# Old items must have been flipped to completed / finished earlier# (sanity – we already asserted this above, but we keep it close for clarity)- old_items = server.batch_manager.list_llm_batch_items(+ old_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=pre_resume_response.last_llm_batch_id, actor=default_user)assert {i.request_status for i in old_items} == {JobStatus.completed}@@ -920,9 +911,9 @@ async def test_resume_step_after_request_all_continue(assert agent_messages[-4].role == MessageRole.user, "Expected final system-level heartbeat user message"[email protected](loop_scope="session")async def test_step_until_request_prepares_and_submits_batch_correctly(- disable_e2b_api_key, server, default_user, agents, batch_requests, step_state_map, dummy_batch_response, batch_job, event_loop+ disable_e2b_api_key, server, default_user, agents, batch_requests, step_state_map, dummy_batch_response, batch_job):"""Test that step_until_request correctly:@@ -1013,7 +1004,7 @@ async def test_step_until_request_prepares_and_submits_batch_correctly(assert len(llm_batch_jobs) == 1, f"Expected 1 llm_batch_jobs, got {len(llm_batch_jobs)}"llm_batch_job = llm_batch_jobs[0]- llm_batch_items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ llm_batch_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(llm_batch_items) == 3, f"Expected 3 llm_batch_items, got {len(llm_batch_items)}"# Verify job propertiesdiff --git a/tests/test_managers.py b/tests/test_managers.pyindex afb5353cf..2a05ba4cf 100644--- a/tests/test_managers.py+++ b/tests/test_managers.py@@ -2218,9 +2218,10 @@ def test_get_tool_with_actor(server: SyncServer, print_tool, default_user):assert fetched_tool.tool_type == ToolType.CUSTOM-def test_list_tools(server: SyncServer, print_tool, default_user):+async def test_list_tools(server: SyncServer, print_tool, default_user, event_loop):# List tools (should include the one created by the fixture)- tools = server.tool_manager.list_tools(actor=default_user)+ tools = await server.tool_manager.list_tools_async(actor=default_user)# Assertions to check that the created tool is listedassert len(tools) == 1@@ -2344,11 +2345,12 @@ def test_update_tool_multi_user(server: SyncServer, print_tool, default_user, otassert updated_tool.created_by_id == default_user.id-def test_delete_tool_by_id(server: SyncServer, print_tool, default_user):+async def test_delete_tool_by_id(server: SyncServer, print_tool, default_user, event_loop):# Delete the print_tool using the manager methodserver.tool_manager.delete_tool_by_id(print_tool.id, actor=default_user)- tools = server.tool_manager.list_tools(actor=default_user)+ tools = await server.tool_manager.list_tools_async(actor=default_user)assert len(tools) == 0@@ -4997,8 +4999,9 @@ def test_list_tags(server: SyncServer, default_user, default_organization):# ======================================================================================================================-def test_create_and_get_batch_request(server, default_user, dummy_beta_message_batch, letta_batch_job):- batch = server.batch_manager.create_llm_batch_job(+async def test_create_and_get_batch_request(server, default_user, dummy_beta_message_batch, letta_batch_job, event_loop):+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5007,12 +5010,13 @@ def test_create_and_get_batch_request(server, default_user, dummy_beta_message_b)assert batch.id.startswith("batch_req-")assert batch.create_batch_response == dummy_beta_message_batch- fetched = server.batch_manager.get_llm_batch_job_by_id(batch.id, actor=default_user)+ fetched = await server.batch_manager.get_llm_batch_job_by_id_async(batch.id, actor=default_user)assert fetched.id == batch.id-def test_update_batch_status(server, default_user, dummy_beta_message_batch, letta_batch_job):- batch = server.batch_manager.create_llm_batch_job(+async def test_update_batch_status(server, default_user, dummy_beta_message_batch, letta_batch_job, event_loop):+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5028,16 +5032,17 @@ def test_update_batch_status(server, default_user, dummy_beta_message_batch, letactor=default_user,)- updated = server.batch_manager.get_llm_batch_job_by_id(batch.id, actor=default_user)+ updated = await server.batch_manager.get_llm_batch_job_by_id_async(batch.id, actor=default_user)assert updated.status == JobStatus.completedassert updated.latest_polling_response == dummy_beta_message_batchassert updated.last_polled_at >= before-def test_create_and_get_batch_item(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_create_and_get_batch_item(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5061,7 +5066,8 @@ def test_create_and_get_batch_item(assert fetched.id == item.id-def test_update_batch_item(+async def test_update_batch_item(server,default_user,sarah_agent,@@ -5070,8 +5076,9 @@ def test_update_batch_item(dummy_step_state,dummy_successful_response,letta_batch_job,+ event_loop,):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5103,10 +5110,11 @@ def test_update_batch_item(assert updated.batch_request_result == dummy_successful_response-def test_delete_batch_item(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_delete_batch_item(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5128,8 +5136,9 @@ def test_delete_batch_item(server.batch_manager.get_llm_batch_item_by_id(item.id, actor=default_user)-def test_list_running_batches(server, default_user, dummy_beta_message_batch, letta_batch_job):- server.batch_manager.create_llm_batch_job(+async def test_list_running_batches(server, default_user, dummy_beta_message_batch, letta_batch_job, event_loop):+ await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.running,create_batch_response=dummy_beta_message_batch,@@ -5137,13 +5146,14 @@ def test_list_running_batches(server, default_user, dummy_beta_message_batch, leletta_batch_job_id=letta_batch_job.id,)- running_batches = server.batch_manager.list_running_llm_batches(actor=default_user)+ running_batches = await server.batch_manager.list_running_llm_batches_async(actor=default_user)assert len(running_batches) >= 1assert all(batch.status == JobStatus.running for batch in running_batches)-def test_bulk_update_batch_statuses(server, default_user, dummy_beta_message_batch, letta_batch_job):- batch = server.batch_manager.create_llm_batch_job(+async def test_bulk_update_batch_statuses(server, default_user, dummy_beta_message_batch, letta_batch_job, event_loop):+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,@@ -5153,12 +5163,13 @@ def test_bulk_update_batch_statuses(server, default_user, dummy_beta_message_batserver.batch_manager.bulk_update_llm_batch_statuses([(batch.id, JobStatus.completed, dummy_beta_message_batch)])- updated = server.batch_manager.get_llm_batch_job_by_id(batch.id, actor=default_user)+ updated = await server.batch_manager.get_llm_batch_job_by_id_async(batch.id, actor=default_user)assert updated.status == JobStatus.completedassert updated.latest_polling_response == dummy_beta_message_batch-def test_bulk_update_batch_items_results_by_agent(+async def test_bulk_update_batch_items_results_by_agent(server,default_user,sarah_agent,@@ -5167,8 +5178,9 @@ def test_bulk_update_batch_items_results_by_agent(dummy_step_state,dummy_successful_response,letta_batch_job,+ event_loop,):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5191,10 +5203,11 @@ def test_bulk_update_batch_items_results_by_agent(assert updated.batch_request_result == dummy_successful_response-def test_bulk_update_batch_items_step_status_by_agent(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_bulk_update_batch_items_step_status_by_agent(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5216,10 +5229,11 @@ def test_bulk_update_batch_items_step_status_by_agent(assert updated.step_status == AgentStepStatus.resumed-def test_list_batch_items_limit_and_filter(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_list_batch_items_limit_and_filter(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5235,18 +5249,19 @@ def test_list_batch_items_limit_and_filter(actor=default_user,)- all_items = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, actor=default_user)- limited_items = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, limit=2, actor=default_user)+ all_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=batch.id, actor=default_user)+ limited_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=batch.id, limit=2, actor=default_user)assert len(all_items) >= 3assert len(limited_items) == 2-def test_list_batch_items_pagination(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_list_batch_items_pagination(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):# Create a batch job.- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5266,7 +5281,7 @@ def test_list_batch_items_pagination(created_items.append(item)# Retrieve all items (without pagination).- all_items = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, actor=default_user)+ all_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=batch.id, actor=default_user)assert len(all_items) >= 10, f"Expected at least 10 items, got {len(all_items)}"# Verify the items are ordered ascending by id (based on our implementation).@@ -5278,7 +5293,7 @@ def test_list_batch_items_pagination(cursor = all_items[4].id# Retrieve items after the cursor.- paged_items = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, actor=default_user, after=cursor)+ paged_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=batch.id, actor=default_user, after=cursor)# All returned items should have an id greater than the cursor.for item in paged_items:@@ -5292,7 +5307,9 @@ def test_list_batch_items_pagination(# Test pagination with a limit.limit = 3- limited_page = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, actor=default_user, after=cursor, limit=limit)+ limited_page = await server.batch_manager.list_llm_batch_items_async(+ llm_batch_id=batch.id, actor=default_user, after=cursor, limit=limit+ )# If more than 'limit' items remain, we should only get exactly 'limit' items.assert len(limited_page) == min(limit, expected_remaining@@ -5300,15 +5317,16 @@ def test_list_batch_items_pagination(# Optional: Test with a cursor beyond the last item returns an empty list.last_cursor = sorted_ids[-1]- empty_page = server.batch_manager.list_llm_batch_items(llm_batch_id=batch.id, actor=default_user, after=last_cursor)+ empty_page = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=batch.id, actor=default_user, after=last_cursor)assert empty_page == [], "Expected an empty list when cursor is after the last item"-def test_bulk_update_batch_items_request_status_by_agent(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_bulk_update_batch_items_request_status_by_agent(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):# Create a batch job- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5334,15 +5352,17 @@ def test_bulk_update_batch_items_request_status_by_agent(assert updated.request_status == JobStatus.expired-def test_bulk_update_nonexistent_items_should_error(+async def test_bulk_update_nonexistent_items_should_error(server,default_user,dummy_beta_message_batch,dummy_successful_response,letta_batch_job,+ event_loop,):# Create a batch job- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5375,9 +5395,12 @@ def test_bulk_update_nonexistent_items_should_error()-def test_bulk_update_nonexistent_items(server, default_user, dummy_beta_message_batch, dummy_successful_response, letta_batch_job):+async def test_bulk_update_nonexistent_items(+ server, default_user, dummy_beta_message_batch, dummy_successful_response, letta_batch_job, event_loop+):# Create a batch job- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5410,11 +5433,12 @@ def test_bulk_update_nonexistent_items(server, default_user, dummy_beta_message_)-def test_create_batch_items_bulk(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_create_batch_items_bulk(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):# Create a batch job- llm_batch_job = server.batch_manager.create_llm_batch_job(+ llm_batch_job = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,create_batch_response=dummy_beta_message_batch,actor=default_user,@@ -5437,7 +5461,7 @@ def test_create_batch_items_bulk(batch_items.append(batch_item)# Call the bulk create function- created_items = server.batch_manager.create_llm_batch_items_bulk(batch_items, actor=default_user)+ created_items = await server.batch_manager.create_llm_batch_items_bulk_async(batch_items, actor=default_user)# Verify the correct number of items were createdassert len(created_items) == len(agent_ids)@@ -5453,7 +5477,7 @@ def test_create_batch_items_bulk(assert item.step_state == dummy_step_state# Verify items can be retrieved from the database- all_items = server.batch_manager.list_llm_batch_items(llm_batch_id=llm_batch_job.id, actor=default_user)+ all_items = await server.batch_manager.list_llm_batch_items_async(llm_batch_id=llm_batch_job.id, actor=default_user)assert len(all_items) >= len(agent_ids)# Verify the IDs of created items match what's in the database@@ -5463,11 +5487,12 @@ def test_create_batch_items_bulk(assert fetched.id in created_ids-def test_count_batch_items(- server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job+async def test_count_batch_items(+ server, default_user, sarah_agent, dummy_beta_message_batch, dummy_llm_config, dummy_step_state, letta_batch_job, event_loop):# Create a batch job first.- batch = server.batch_manager.create_llm_batch_job(+ batch = await server.batch_manager.create_llm_batch_job_async(llm_provider=ProviderType.anthropic,status=JobStatus.created,create_batch_response=dummy_beta_message_batch,