letta-nightly 0.7.15.dev20250514104255__py3-none-any.whl → 0.7.16.dev20250515205957__py3-none-any.whl

letta/services/job_manager.py

@@ -44,6 +44,19 @@ class JobManager:
             job.create(session, actor=actor)  # Save job in the database
         return 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_types
     def 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."""
@@ -68,6 +81,30 @@ class JobManager:
 
             return job.to_pydantic()
 
+    @enforce_types
+    async def update_job_by_id_async(self, job_id: str, job_update: JobUpdate, actor: PydanticUser) -> PydanticJob:
+        """Update a job by its ID with the given JobUpdate object asynchronously."""
+        async with db_registry.async_session() as session:
+            # Fetch the job by ID
+            job = await self._verify_job_access_async(session=session, job_id=job_id, actor=actor, access=["write"])
+
+            # Update job attributes with only the fields that were explicitly set
+            update_data = job_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
+
+            # Automatically update the completion timestamp if status is set to 'completed'
+            for key, value in update_data.items():
+                setattr(job, key, value)
+
+            if update_data.get("status") == JobStatus.completed and not job.completed_at:
+                job.completed_at = get_utc_time()
+                if job.callback_url:
+                    await self._dispatch_callback_async(session, job)
+
+            # Save the updated job to the database
+            await job.update_async(db_session=session, actor=actor)
+
+            return job.to_pydantic()
+
     @enforce_types
     def get_job_by_id(self, job_id: str, actor: PydanticUser) -> PydanticJob:
         """Fetch a job by its ID."""
@@ -76,6 +113,14 @@ class JobManager:
             job = JobModel.read(db_session=session, identifier=job_id, actor=actor, access_type=AccessType.USER)
             return job.to_pydantic()
 
+    @enforce_types
+    async def get_job_by_id_async(self, job_id: str, actor: PydanticUser) -> PydanticJob:
+        """Fetch a job by its ID asynchronously."""
+        async with db_registry.async_session() as session:
+            # Retrieve job by ID using the Job model's read method
+            job = await JobModel.read_async(db_session=session, identifier=job_id, actor=actor, access_type=AccessType.USER)
+            return job.to_pydantic()
+
     @enforce_types
     def list_jobs(
         self,
@@ -438,6 +483,35 @@ class JobManager:
             raise NoResultFound(f"Job with id {job_id} does not exist or user does not have access")
         return job
 
+    async def _verify_job_access_async(
+        self,
+        session: Session,
+        job_id: str,
+        actor: PydanticUser,
+        access: List[Literal["read", "write", "delete"]] = ["read"],
+    ) -> JobModel:
+        """
+        Verify that a job exists and the user has the required access.
+
+        Args:
+            session: The database session
+            job_id: The ID of the job to verify
+            actor: The user making the request
+
+        Returns:
+            The job if it exists and the user has access
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        job_query = select(JobModel).where(JobModel.id == job_id)
+        job_query = JobModel.apply_access_predicate(job_query, actor, access, AccessType.USER)
+        result = await session.execute(job_query)
+        job = result.scalar_one_or_none()
+        if not job:
+            raise NoResultFound(f"Job with id {job_id} does not exist or user does not have access")
+        return job
+
     def _get_run_request_config(self, run_id: str) -> LettaRequestConfig:
         """
         Get the request config for a job.
@@ -476,3 +550,28 @@ class JobManager:
 
         session.add(job)
         session.commit()
+
+    async def _dispatch_callback_async(self, session, job: JobModel) -> None:
+        """
+        POST a standard JSON payload to job.callback_url
+        and record timestamp + HTTP status asynchronously.
+        """
+
+        payload = {
+            "job_id": job.id,
+            "status": job.status,
+            "completed_at": job.completed_at.isoformat(),
+        }
+        try:
+            import httpx
+
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(job.callback_url, json=payload, timeout=5.0)
+                job.callback_sent_at = get_utc_time()
+                job.callback_status_code = resp.status_code
+
+        except Exception:
+            return
+
+        session.add(job)
+        await session.commit()

letta/services/llm_batch_manager.py

@@ -2,7 +2,7 @@ import datetime
 from typing import Any, Dict, List, Optional, Tuple
 
 from 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, StepStatusUpdateInfo
 from 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_types
     def 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 objects
             orm_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 models
             return [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 filters
             if 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 = True

letta/services/message_manager.py

@@ -36,15 +36,29 @@ class MessageManager:
         """Fetch messages by ID and return them in the requested order."""
         with db_registry.session() as session:
             results = MessageModel.list(db_session=session, id=message_ids, organization_id=actor.organization_id, limit=len(message_ids))
+        return self._get_messages_by_id_postprocess(results, message_ids)
 
-            if len(results) != len(message_ids):
-                logger.warning(
-                    f"Expected {len(message_ids)} messages, but found {len(results)}. Missing ids={set(message_ids) - set([r.id for r in results])}"
-                )
+    @enforce_types
+    async def get_messages_by_ids_async(self, message_ids: List[str], actor: PydanticUser) -> List[PydanticMessage]:
+        """Fetch messages by ID and return them in the requested order. Async version of above function."""
+        async with db_registry.async_session() as session:
+            results = await MessageModel.list_async(
+                db_session=session, id=message_ids, organization_id=actor.organization_id, limit=len(message_ids)
+            )
+        return self._get_messages_by_id_postprocess(results, message_ids)
 
-            # Sort results directly based on message_ids
-            result_dict = {msg.id: msg.to_pydantic() for msg in results}
-            return list(filter(lambda x: x is not None, [result_dict.get(msg_id, None) for msg_id in message_ids]))
+    def _get_messages_by_id_postprocess(
+        self,
+        results: List[MessageModel],
+        message_ids: List[str],
+    ) -> List[PydanticMessage]:
+        if len(results) != len(message_ids):
+            logger.warning(
+                f"Expected {len(message_ids)} messages, but found {len(results)}. Missing ids={set(message_ids) - set([r.id for r in results])}"
+            )
+        # Sort results directly based on message_ids
+        result_dict = {msg.id: msg.to_pydantic() for msg in results}
+        return list(filter(lambda x: x is not None, [result_dict.get(msg_id, None) for msg_id in message_ids]))
 
     @enforce_types
     def create_message(self, pydantic_msg: PydanticMessage, actor: PydanticUser) -> PydanticMessage:
@@ -57,11 +71,20 @@ class MessageManager:
             msg.create(session, actor=actor)  # Persist to database
             return 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_types
     def create_many_messages(self, pydantic_msgs: List[PydanticMessage], actor: PydanticUser) -> List[PydanticMessage]:
         """
         Create multiple messages in a single database transaction.
-
         Args:
             pydantic_msgs: List of Pydantic message models to create
             actor: User performing the action
@@ -69,23 +92,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_types

letta/services/tool_executor/tool_executor.py

@@ -3,7 +3,12 @@ import traceback
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 
-from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY, CORE_MEMORY_LINE_NUMBER_WARNING, RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+from letta.constants import (
+    COMPOSIO_ENTITY_ENV_VAR_KEY,
+    CORE_MEMORY_LINE_NUMBER_WARNING,
+    READ_ONLY_BLOCK_EDIT_ERROR,
+    RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE,
+)
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.composio_helpers import execute_composio_action_async, generate_composio_action_from_func_name
 from letta.helpers.composio_helpers import get_composio_api_key
@@ -203,6 +208,8 @@ class LettaCoreToolExecutor(ToolExecutor):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
+        if agent_state.memory.get_block(label).read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
         current_value = str(agent_state.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
         agent_state.memory.update_block_value(label=label, value=new_value)
@@ -228,6 +235,8 @@ class LettaCoreToolExecutor(ToolExecutor):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
+        if agent_state.memory.get_block(label).read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
         current_value = str(agent_state.memory.get_block(label).value)
         if old_content not in current_value:
             raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
@@ -260,6 +269,9 @@ class LettaCoreToolExecutor(ToolExecutor):
         """
         import re
 
+        if agent_state.memory.get_block(label).read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
+
         if bool(re.search(r"\nLine \d+: ", old_str)):
             raise ValueError(
                 "old_str contains a line number prefix, which is not allowed. "
@@ -349,6 +361,9 @@ class LettaCoreToolExecutor(ToolExecutor):
         """
         import re
 
+        if agent_state.memory.get_block(label).read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
+
         if bool(re.search(r"\nLine \d+: ", new_str)):
             raise ValueError(
                 "new_str contains a line number prefix, which is not allowed. Do not "
@@ -426,6 +441,9 @@ class LettaCoreToolExecutor(ToolExecutor):
         """
         import re
 
+        if agent_state.memory.get_block(label).read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
+
         if bool(re.search(r"\nLine \d+: ", new_memory)):
             raise ValueError(
                 "new_memory contains a line number prefix, which is not allowed. Do not "

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_types
     def 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,

{letta_nightly-0.7.15.dev20250514104255.dist-info → letta_nightly-0.7.16.dev20250515205957.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.15.dev20250514104255
+Version: 0.7.16.dev20250515205957
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -51,7 +51,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.141,<0.2.0)
+Requires-Dist: letta_client (>=0.1.143,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
@@ -77,7 +77,7 @@ Requires-Dist: pydantic (>=2.10.6,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
 Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
-Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev" or extra == "all"
+Requires-Dist: pytest-asyncio (>=0.24.0,<0.25.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pytest-order (>=1.2.0,<2.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: python-box (>=7.1.1,<8.0.0)
 Requires-Dist: python-multipart (>=0.0.19,<0.0.20)