letta-nightly 0.8.15.dev20250719104256__py3-none-any.whl → 0.8.16.dev20250721070720__py3-none-any.whl

letta/services/job_manager.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from functools import partial, reduce
 from operator import add
 from typing import List, Literal, Optional, Union
@@ -27,6 +28,7 @@ from letta.schemas.step import Step as PydanticStep
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
+from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
 
 logger = get_logger(__name__)
@@ -60,15 +62,29 @@ class JobManager:
             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()
+            job = await job.create_async(session, actor=actor, no_commit=True, no_refresh=True)  # Save job in the database
+            result = job.to_pydantic()
+            await session.commit()
+            return result
 
     @enforce_types
     @trace_method
     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."""
+        # First check if we need to dispatch a callback
+        needs_callback = False
+        callback_url = None
+        with db_registry.session() as session:
+            job = self._verify_job_access(session=session, job_id=job_id, actor=actor, access=["write"])
+            not_completed_before = not bool(job.completed_at)
+
+            # Check if we'll need to dispatch callback
+            if job_update.status in {JobStatus.completed, JobStatus.failed} and not_completed_before and job.callback_url:
+                needs_callback = True
+                callback_url = job.callback_url
+
+        # Update the job first to get the final metadata
         with db_registry.session() as session:
-            # Fetch the job by ID
             job = self._verify_job_access(session=session, job_id=job_id, actor=actor, access=["write"])
             not_completed_before = not bool(job.completed_at)
 
@@ -84,24 +100,66 @@ class JobManager:
 
             if job_update.status in {JobStatus.completed, JobStatus.failed} and not_completed_before:
                 job.completed_at = get_utc_time().replace(tzinfo=None)
-                if job.callback_url:
-                    self._dispatch_callback(job)
 
-            # Save the updated job to the database
-            job.update(db_session=session, actor=actor)
-
-            return job.to_pydantic()
+            # Save the updated job to the database first
+            job = job.update(db_session=session, actor=actor)
+
+            # Get the updated metadata for callback
+            final_metadata = job.metadata_
+            result = job.to_pydantic()
+
+        # Dispatch callback outside of database session if needed
+        if needs_callback:
+            callback_info = {
+                "job_id": job_id,
+                "callback_url": callback_url,
+                "status": job_update.status,
+                "completed_at": get_utc_time().replace(tzinfo=None),
+                "metadata": final_metadata,
+            }
+            callback_result = self._dispatch_callback_sync(callback_info)
+
+            # Update callback status in a separate transaction
+            with db_registry.session() as session:
+                job = self._verify_job_access(session=session, job_id=job_id, actor=actor, access=["write"])
+                job.callback_sent_at = callback_result["callback_sent_at"]
+                job.callback_status_code = callback_result.get("callback_status_code")
+                job.callback_error = callback_result.get("callback_error")
+                job.update(db_session=session, actor=actor)
+                result = job.to_pydantic()
+
+        return result
 
     @enforce_types
     @trace_method
-    async def update_job_by_id_async(self, job_id: str, job_update: JobUpdate, actor: PydanticUser) -> PydanticJob:
+    async def update_job_by_id_async(
+        self, job_id: str, job_update: JobUpdate, actor: PydanticUser, safe_update: bool = False
+    ) -> PydanticJob:
         """Update a job by its ID with the given JobUpdate object asynchronously."""
-        callback_func = None
-
+        # First check if we need to dispatch a callback
+        needs_callback = False
+        callback_url = None
         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"])
 
+            # Safely update job status with state transition guards: Created -> Pending -> Running --> <Terminal>
+            if safe_update:
+                current_status = JobStatus(job.status)
+                if not any(
+                    (
+                        job_update.status.is_terminal and not current_status.is_terminal,
+                        current_status == JobStatus.created and job_update.status != JobStatus.created,
+                        current_status == JobStatus.pending and job_update.status == JobStatus.running,
+                    )
+                ):
+                    logger.error(f"Invalid job status transition from {current_status} to {job_update.status} for job {job_id}")
+                    raise ValueError(f"Invalid job status transition from {current_status} to {job_update.status}")
+
+            # Check if we'll need to dispatch callback
+            if job_update.status in {JobStatus.completed, JobStatus.failed} and job.callback_url:
+                needs_callback = True
+                callback_url = job.callback_url
+
             # 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)
 
@@ -116,25 +174,37 @@ class JobManager:
             if job_update.status in {JobStatus.completed, JobStatus.failed}:
                 logger.info(f"Current job completed at: {job.completed_at}")
                 job.completed_at = get_utc_time().replace(tzinfo=None)
-                if job.callback_url:
-                    callback_func = self._dispatch_callback_async(
-                        callback_url=job.callback_url,
-                        payload={
-                            "job_id": job.id,
-                            "status": job.status,
-                            "completed_at": job.completed_at.isoformat() if job.completed_at else None,
-                            "metadata": job.metadata_,
-                        },
-                        actor=actor,
-                    )
 
-            # Save the updated job to the database
-            await job.update_async(db_session=session, actor=actor)
+            # Save the updated job to the database first
+            job = await job.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
 
-            if callback_func:
-                return await callback_func
+            # Get the updated metadata for callback
+            final_metadata = job.metadata_
+            result = job.to_pydantic()
+            await session.commit()
 
-            return job.to_pydantic()
+        # Dispatch callback outside of database session if needed
+        if needs_callback:
+            callback_info = {
+                "job_id": job_id,
+                "callback_url": callback_url,
+                "status": job_update.status,
+                "completed_at": get_utc_time().replace(tzinfo=None),
+                "metadata": final_metadata,
+            }
+            callback_result = await self._dispatch_callback_async(callback_info)
+
+            # Update callback status in a separate transaction
+            async with db_registry.async_session() as session:
+                job = await self._verify_job_access_async(session=session, job_id=job_id, actor=actor, access=["write"])
+                job.callback_sent_at = callback_result["callback_sent_at"]
+                job.callback_status_code = callback_result.get("callback_status_code")
+                job.callback_error = callback_result.get("callback_error")
+                await job.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
+                result = job.to_pydantic()
+                await session.commit()
+
+        return result
 
     @enforce_types
     @trace_method
@@ -149,20 +219,6 @@ class JobManager:
             True if update was successful, False if update was skipped due to invalid transition
         """
         try:
-            # Get current job state
-            current_job = await self.get_job_by_id_async(job_id=job_id, actor=actor)
-
-            current_status = current_job.status
-            if not any(
-                (
-                    new_status.is_terminal and not current_status.is_terminal,
-                    current_status == JobStatus.created and new_status != JobStatus.created,
-                    current_status == JobStatus.pending and new_status == JobStatus.running,
-                )
-            ):
-                logger.warning(f"Invalid job status transition from {current_job.status} to {new_status} for job {job_id}")
-                return False
-
             job_update_builder = partial(JobUpdate, status=new_status)
             if metadata:
                 job_update_builder = partial(job_update_builder, metadata=metadata)
@@ -238,24 +294,90 @@ class JobManager:
         source_id: Optional[str] = None,
     ) -> List[PydanticJob]:
         """List all jobs with optional pagination and status filter."""
+        from sqlalchemy import and_, or_, select
+
         async with db_registry.async_session() as session:
-            filter_kwargs = {"user_id": actor.id, "job_type": job_type}
+            # build base query
+            query = select(JobModel).where(JobModel.user_id == actor.id).where(JobModel.job_type == job_type)
 
-            # Add status filter if provided
+            # add status filter if provided
             if statuses:
-                filter_kwargs["status"] = statuses
+                query = query.where(JobModel.status.in_(statuses))
 
+            # add source_id filter if provided
             if source_id:
-                filter_kwargs["metadata_.source_id"] = source_id
+                column = getattr(JobModel, "metadata_")
+                column = column.op("->>")("source_id")
+                query = query.where(column == source_id)
+
+            # handle cursor-based pagination
+            if before or after:
+                # get cursor objects
+                before_obj = None
+                after_obj = None
+
+                if before:
+                    before_obj = await session.get(JobModel, before)
+                    if not before_obj:
+                        raise ValueError(f"Job with id {before} not found")
+
+                if after:
+                    after_obj = await session.get(JobModel, after)
+                    if not after_obj:
+                        raise ValueError(f"Job with id {after} not found")
+
+                # validate cursors
+                if before_obj and after_obj:
+                    if before_obj.created_at < after_obj.created_at:
+                        raise ValueError("'before' reference must be later than 'after' reference")
+                    elif before_obj.created_at == after_obj.created_at and before_obj.id < after_obj.id:
+                        raise ValueError("'before' reference must be later than 'after' reference")
+
+                # build cursor conditions
+                conditions = []
+                if before_obj:
+                    # records before this cursor (older)
+
+                    before_timestamp = before_obj.created_at
+                    # SQLite does not support as granular timestamping, so we need to round the timestamp
+                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(before_timestamp, datetime):
+                        before_timestamp = before_timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+                    conditions.append(
+                        or_(
+                            JobModel.created_at < before_timestamp,
+                            and_(JobModel.created_at == before_timestamp, JobModel.id < before_obj.id),
+                        )
+                    )
+
+                if after_obj:
+                    # records after this cursor (newer)
+                    after_timestamp = after_obj.created_at
+                    # SQLite does not support as granular timestamping, so we need to round the timestamp
+                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(after_timestamp, datetime):
+                        after_timestamp = after_timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+                    conditions.append(
+                        or_(JobModel.created_at > after_timestamp, and_(JobModel.created_at == after_timestamp, JobModel.id > after_obj.id))
+                    )
+
+                if conditions:
+                    query = query.where(and_(*conditions))
+
+            # apply ordering
+            if ascending:
+                query = query.order_by(JobModel.created_at.asc(), JobModel.id.asc())
+            else:
+                query = query.order_by(JobModel.created_at.desc(), JobModel.id.desc())
+
+            # apply limit
+            if limit:
+                query = query.limit(limit)
+
+            # execute query
+            result = await session.execute(query)
+            jobs = result.scalars().all()
 
-            jobs = await JobModel.list_async(
-                db_session=session,
-                before=before,
-                after=after,
-                limit=limit,
-                ascending=ascending,
-                **filter_kwargs,
-            )
             return [job.to_pydantic() for job in jobs]
 
     @enforce_types
@@ -617,7 +739,7 @@ class JobManager:
         session: Session,
         job_id: str,
         actor: PydanticUser,
-        access: List[Literal["read", "write", "delete"]] = ["read"],
+        access: List[Literal["read", "write", "admin"]] = ["read"],
     ) -> JobModel:
         """
         Verify that a job exists and the user has the required access.
@@ -685,61 +807,58 @@ class JobManager:
         return request_config
 
     @trace_method
-    def _dispatch_callback(self, job: JobModel) -> None:
+    def _dispatch_callback_sync(self, callback_info: dict) -> dict:
         """
-        POST a standard JSON payload to job.callback_url
-        and record timestamp + HTTP status.
+        POST a standard JSON payload to callback_url and return callback status.
         """
-
         payload = {
-            "job_id": job.id,
-            "status": job.status,
-            "completed_at": job.completed_at.isoformat() if job.completed_at else None,
-            "metadata": job.metadata_,
+            "job_id": callback_info["job_id"],
+            "status": callback_info["status"],
+            "completed_at": callback_info["completed_at"].isoformat() if callback_info["completed_at"] else None,
+            "metadata": callback_info["metadata"],
         }
+
+        callback_sent_at = get_utc_time().replace(tzinfo=None)
+        result = {"callback_sent_at": callback_sent_at}
+
         try:
             log_event("POST callback dispatched", payload)
-            resp = post(job.callback_url, json=payload, timeout=5.0)
+            resp = post(callback_info["callback_url"], json=payload, timeout=5.0)
             log_event("POST callback finished")
-            job.callback_sent_at = get_utc_time().replace(tzinfo=None)
-            job.callback_status_code = resp.status_code
-
+            result["callback_status_code"] = resp.status_code
         except Exception as e:
-            error_message = f"Failed to dispatch callback for job {job.id} to {job.callback_url}: {e!s}"
+            error_message = f"Failed to dispatch callback for job {callback_info['job_id']} to {callback_info['callback_url']}: {e!s}"
             logger.error(error_message)
-            # Record the failed attempt
-            job.callback_sent_at = get_utc_time().replace(tzinfo=None)
-            job.callback_error = error_message
+            result["callback_error"] = error_message
             # Continue silently - callback failures should not affect job completion
 
+        return result
+
     @trace_method
-    async def _dispatch_callback_async(self, callback_url: str, payload: dict, actor: PydanticUser) -> PydanticJob:
+    async def _dispatch_callback_async(self, callback_info: dict) -> dict:
         """
-        POST a standard JSON payload to job.callback_url and record timestamp + HTTP status asynchronously.
+        POST a standard JSON payload to callback_url and return callback status asynchronously.
         """
-        job_id = payload["job_id"]
-        callback_sent_at, callback_status_code, callback_error = None, None, None
+        payload = {
+            "job_id": callback_info["job_id"],
+            "status": callback_info["status"],
+            "completed_at": callback_info["completed_at"].isoformat() if callback_info["completed_at"] else None,
+            "metadata": callback_info["metadata"],
+        }
+
+        callback_sent_at = get_utc_time().replace(tzinfo=None)
+        result = {"callback_sent_at": callback_sent_at}
 
         try:
             async with AsyncClient() as client:
                 log_event("POST callback dispatched", payload)
-                resp = await client.post(callback_url, json=payload, timeout=5.0)
+                resp = await client.post(callback_info["callback_url"], json=payload, timeout=5.0)
                 log_event("POST callback finished")
-                # Ensure timestamp is timezone-naive for DB compatibility
-                callback_sent_at = get_utc_time().replace(tzinfo=None)
-                callback_status_code = resp.status_code
+                result["callback_status_code"] = resp.status_code
         except Exception as e:
-            error_message = f"Failed to dispatch callback for job {job_id} to {callback_url}: {e!s}"
+            error_message = f"Failed to dispatch callback for job {callback_info['job_id']} to {callback_info['callback_url']}: {e!s}"
             logger.error(error_message)
-            # Record the failed attempt
-            callback_sent_at = get_utc_time().replace(tzinfo=None)
-            callback_error = error_message
+            result["callback_error"] = error_message
             # Continue silently - callback failures should not affect job completion
 
-        async with db_registry.async_session() as session:
-            job = await JobModel.read_async(db_session=session, identifier=job_id, actor=actor, access_type=AccessType.USER)
-            job.callback_sent_at = callback_sent_at
-            job.callback_status_code = callback_status_code
-            job.callback_error = callback_error
-            await job.update_async(db_session=session, actor=actor)
-            return job.to_pydantic()
+        return result

letta/services/llm_batch_manager.py

@@ -45,8 +45,10 @@ class LLMBatchManager:
                 organization_id=actor.organization_id,
                 letta_batch_job_id=letta_batch_job_id,
             )
-            await batch.create_async(session, actor=actor)
-            return batch.to_pydantic()
+            await batch.create_async(session, actor=actor, no_commit=True, no_refresh=True)
+            pydantic_batch = batch.to_pydantic()
+            await session.commit()
+            return pydantic_batch
 
     @enforce_types
     @trace_method
@@ -282,10 +284,11 @@ class LLMBatchManager:
                 )
                 orm_items.append(orm_item)
 
-            created_items = await LLMBatchItem.batch_create_async(orm_items, session, actor=actor)
+            created_items = await LLMBatchItem.batch_create_async(orm_items, session, actor=actor, no_commit=True, no_refresh=True)
 
-            # Convert back to Pydantic models
-            return [item.to_pydantic() for item in created_items]
+            pydantic_items = [item.to_pydantic() for item in created_items]
+            await session.commit()
+            return pydantic_items
 
     @enforce_types
     @trace_method
@@ -403,7 +406,7 @@ class LLMBatchManager:
                 missing = requested - found
                 if missing:
                     raise ValueError(
-                        f"Cannot bulk-update batch items: no records for the following " f"(llm_batch_id, agent_id) pairs: {missing}"
+                        f"Cannot bulk-update batch items: no records for the following (llm_batch_id, agent_id) pairs: {missing}"
                     )
 
             # Build mappings, skipping any missing when strict=False

letta/services/mcp/stdio_client.py

@@ -11,11 +11,10 @@ logger = get_logger(__name__)
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncStdioMCPClient(AsyncBaseMCPClient):
     async def _initialize_connection(self, server_config: StdioServerConfig) -> None:
-
         args = [arg.split() for arg in server_config.args]
         # flatten
         args = [arg for sublist in args for arg in sublist]
-        server_params = StdioServerParameters(command=server_config.command, args=args)
+        server_params = StdioServerParameters(command=server_config.command, args=args, env=server_config.env)
         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
         self.stdio, self.write = stdio_transport
         self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))

letta/services/mcp_manager.py

@@ -274,7 +274,6 @@ class MCPManager:
         mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
         if os.path.exists(mcp_config_path):
             with open(mcp_config_path, "r") as f:
-
                 try:
                     mcp_config = json.load(f)
                 except Exception as e:

letta/services/message_manager.py

@@ -17,6 +17,8 @@ from letta.schemas.message import MessageUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.file_manager import FileManager
+from letta.services.helpers.agent_manager_helper import validate_agent_exists_async
+from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
 
 logger = get_logger(__name__)
@@ -86,8 +88,8 @@ class MessageManager:
         """Create a new message."""
         with db_registry.session() as session:
             # Set the organization id of the Pydantic message
-            pydantic_msg.organization_id = actor.organization_id
             msg_data = pydantic_msg.model_dump(to_orm=True)
+            msg_data["organization_id"] = actor.organization_id
             msg = MessageModel(**msg_data)
             msg.create(session, actor=actor)  # Persist to database
             return msg.to_pydantic()
@@ -97,8 +99,8 @@ class MessageManager:
         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)
+            msg_data["organization_id"] = actor.organization_id
             orm_messages.append(MessageModel(**msg_data))
         return orm_messages
 
@@ -165,8 +167,10 @@ class MessageManager:
                         )
         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]
+            created_messages = await MessageModel.batch_create_async(orm_messages, session, actor=actor, no_commit=True, no_refresh=True)
+            result = [msg.to_pydantic() for msg in created_messages]
+            await session.commit()
+            return result
 
     @enforce_types
     @trace_method
@@ -280,8 +284,10 @@ class MessageManager:
             )
 
             message = self._update_message_by_id_impl(message_id, message_update, actor, message)
-            await message.update_async(db_session=session, actor=actor)
-            return message.to_pydantic()
+            await message.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
+            pydantic_message = message.to_pydantic()
+            await session.commit()
+            return pydantic_message
 
     def _update_message_by_id_impl(
         self, message_id: str, message_update: MessageUpdate, actor: PydanticUser, message: MessageModel
@@ -453,17 +459,23 @@ class MessageManager:
             if group_id:
                 query = query.filter(MessageModel.group_id == group_id)
 
-            # If query_text is provided, filter messages using subquery + json_array_elements.
+            # If query_text is provided, filter messages using database-specific JSON search.
             if query_text:
-                content_element = func.json_array_elements(MessageModel.content).alias("content_element")
-                query = query.filter(
-                    exists(
-                        select(1)
-                        .select_from(content_element)
-                        .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
-                        .params(query_text=f"%{query_text}%")
+                if settings.database_engine is DatabaseChoice.POSTGRES:
+                    # PostgreSQL: Use json_array_elements and ILIKE
+                    content_element = func.json_array_elements(MessageModel.content).alias("content_element")
+                    query = query.filter(
+                        exists(
+                            select(1)
+                            .select_from(content_element)
+                            .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
+                            .params(query_text=f"%{query_text}%")
+                        )
                     )
-                )
+                else:
+                    # SQLite: Use JSON_EXTRACT with individual array indices for case-insensitive search
+                    # Since SQLite doesn't support $[*] syntax, we'll use a different approach
+                    query = query.filter(text("JSON_EXTRACT(content, '$') LIKE :query_text")).params(query_text=f"%{query_text}%")
 
             # If role(s) are provided, filter messages by those roles.
             if roles:
@@ -512,6 +524,7 @@ class MessageManager:
         limit: Optional[int] = 50,
         ascending: bool = True,
         group_id: Optional[str] = None,
+        include_err: Optional[bool] = None,
     ) -> List[PydanticMessage]:
         """
         Most performant query to list messages for an agent by directly querying the Message table.
@@ -531,6 +544,7 @@ class MessageManager:
             limit: Maximum number of messages to return.
             ascending: If True, sort by sequence_id ascending; if False, sort descending.
             group_id: Optional group ID to filter messages by group_id.
+            include_err: Optional boolean to include errors and error statuses. Used for debugging only.
 
         Returns:
             List[PydanticMessage]: A list of messages (converted via .to_pydantic()).
@@ -541,7 +555,7 @@ class MessageManager:
 
         async with db_registry.async_session() as session:
             # Permission check: raise if the agent doesn't exist or actor is not allowed.
-            await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
+            await validate_agent_exists_async(session, agent_id, actor)
 
             # Build a query that directly filters the Message table by agent_id.
             query = select(MessageModel).where(MessageModel.agent_id == agent_id)
@@ -550,17 +564,26 @@ class MessageManager:
             if group_id:
                 query = query.where(MessageModel.group_id == group_id)
 
-            # If query_text is provided, filter messages using subquery + json_array_elements.
+            if not include_err:
+                query = query.where((MessageModel.is_err == False) | (MessageModel.is_err.is_(None)))
+
+            # If query_text is provided, filter messages using database-specific JSON search.
             if query_text:
-                content_element = func.json_array_elements(MessageModel.content).alias("content_element")
-                query = query.where(
-                    exists(
-                        select(1)
-                        .select_from(content_element)
-                        .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
-                        .params(query_text=f"%{query_text}%")
+                if settings.database_engine is DatabaseChoice.POSTGRES:
+                    # PostgreSQL: Use json_array_elements and ILIKE
+                    content_element = func.json_array_elements(MessageModel.content).alias("content_element")
+                    query = query.where(
+                        exists(
+                            select(1)
+                            .select_from(content_element)
+                            .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
+                            .params(query_text=f"%{query_text}%")
+                        )
                     )
-                )
+                else:
+                    # SQLite: Use JSON_EXTRACT with individual array indices for case-insensitive search
+                    # Since SQLite doesn't support $[*] syntax, we'll use a different approach
+                    query = query.where(text("JSON_EXTRACT(content, '$') LIKE :query_text")).params(query_text=f"%{query_text}%")
 
             # If role(s) are provided, filter messages by those roles.
             if roles:
@@ -611,7 +634,7 @@ class MessageManager:
         """
         async with db_registry.async_session() as session:
             # 1) verify the agent exists and the actor has access
-            await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
+            await validate_agent_exists_async(session, agent_id, actor)
 
             # 2) issue a CORE DELETE against the mapped class
             stmt = (

letta/services/passage_manager.py

@@ -476,7 +476,6 @@ class PassageManager:
         try:
             # breakup string into passages
             for text in parse_and_chunk_text(text, embedding_chunk_size):
-
                 if agent_state.embedding_config.embedding_endpoint_type != "openai":
                     embedding = embed_model.get_text_embedding(text)
                 else:

letta/services/provider_manager.py

@@ -213,7 +213,7 @@ class ProviderManager:
             provider_type=provider_check.provider_type,
             api_key=provider_check.api_key,
             provider_category=ProviderCategory.byok,
-            secret_key=provider_check.api_secret,
+            access_id_key=provider_check.access_id_key,  # This contains the access key ID for Bedrock
             region=provider_check.region,
         ).cast_to_subtype()