letta-nightly 0.11.7.dev20250915104130__py3-none-any.whl → 0.11.7.dev20250917104122__py3-none-any.whl

letta/services/agent_manager.py

@@ -455,7 +455,8 @@ class AgentManager:
                     [{"agent_id": aid, "identity_id": iid} for iid in identity_ids],
                 )
 
-                if agent_create.tool_exec_environment_variables:
+                agent_secrets = agent_create.secrets or agent_create.tool_exec_environment_variables
+                if agent_secrets:
                     env_rows = [
                         {
                             "agent_id": aid,
@@ -463,7 +464,7 @@ class AgentManager:
                             "value": val,
                             "organization_id": actor.organization_id,
                         }
-                        for key, val in agent_create.tool_exec_environment_variables.items()
+                        for key, val in agent_secrets.items()
                     ]
                     session.execute(insert(AgentEnvironmentVariable).values(env_rows))
 
@@ -674,7 +675,8 @@ class AgentManager:
                 )
 
                 env_rows = []
-                if agent_create.tool_exec_environment_variables:
+                agent_secrets = agent_create.secrets or agent_create.tool_exec_environment_variables
+                if agent_secrets:
                     env_rows = [
                         {
                             "agent_id": aid,
@@ -682,7 +684,7 @@ class AgentManager:
                             "value": val,
                             "organization_id": actor.organization_id,
                         }
-                        for key, val in agent_create.tool_exec_environment_variables.items()
+                        for key, val in agent_secrets.items()
                     ]
                     result = await session.execute(insert(AgentEnvironmentVariable).values(env_rows).returning(AgentEnvironmentVariable.id))
                     env_rows = [{**row, "id": env_var_id} for row, env_var_id in zip(env_rows, result.scalars().all())]
@@ -701,8 +703,9 @@ class AgentManager:
 
                 result = await new_agent.to_pydantic_async(include_relationships=include_relationships)
 
-                if agent_create.tool_exec_environment_variables and env_rows:
+                if agent_secrets and env_rows:
                     result.tool_exec_environment_variables = [AgentEnvironmentVariable(**row) for row in env_rows]
+                    result.secrets = [AgentEnvironmentVariable(**row) for row in env_rows]
 
                 # initial message sequence (skip if _init_with_no_messages is True)
                 if not _init_with_no_messages:
@@ -894,7 +897,8 @@ class AgentManager:
                 )
                 session.expire(agent, ["tags"])
 
-            if agent_update.tool_exec_environment_variables is not None:
+            agent_secrets = agent_update.secrets or agent_update.tool_exec_environment_variables
+            if agent_secrets is not None:
                 session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
                 env_rows = [
                     {
@@ -903,7 +907,7 @@ class AgentManager:
                         "value": v,
                         "organization_id": agent.organization_id,
                     }
-                    for k, v in agent_update.tool_exec_environment_variables.items()
+                    for k, v in agent_secrets.items()
                 ]
                 if env_rows:
                     self._bulk_insert_pivot(session, AgentEnvironmentVariable.__table__, env_rows)
@@ -1019,7 +1023,8 @@ class AgentManager:
                 )
                 session.expire(agent, ["tags"])
 
-            if agent_update.tool_exec_environment_variables is not None:
+            agent_secrets = agent_update.secrets or agent_update.tool_exec_environment_variables
+            if agent_secrets is not None:
                 await session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
                 env_rows = [
                     {
@@ -1028,7 +1033,7 @@ class AgentManager:
                         "value": v,
                         "organization_id": agent.organization_id,
                     }
-                    for k, v in agent_update.tool_exec_environment_variables.items()
+                    for k, v in agent_secrets.items()
                 ]
                 if env_rows:
                     await self._bulk_insert_pivot_async(session, AgentEnvironmentVariable.__table__, env_rows)
@@ -1544,6 +1549,8 @@ class AgentManager:
             if env_vars:
                 for var in agent.tool_exec_environment_variables:
                     var.value = env_vars.get(var.key, "")
+                for var in agent.secrets:
+                    var.value = env_vars.get(var.key, "")
 
             agent = agent.create(session, actor=actor)
 
@@ -1627,6 +1634,7 @@ class AgentManager:
             # Remove stale variables
             stale_keys = set(existing_vars) - set(env_vars)
             agent.tool_exec_environment_variables = [var for var in updated_vars if var.key not in stale_keys]
+            agent.secrets = [var for var in updated_vars if var.key not in stale_keys]
 
             # Update the agent in the database
             agent.update(session, actor=actor)

letta/services/agent_serialization_manager.py

@@ -209,8 +209,10 @@ class AgentSerializationManager:
         agent_schema.id = agent_file_id
 
         # wipe the values of tool_exec_environment_variables (they contain secrets)
-        if agent_schema.tool_exec_environment_variables:
-            agent_schema.tool_exec_environment_variables = {key: "" for key in agent_schema.tool_exec_environment_variables}
+        agent_secrets = agent_schema.secrets or agent_schema.tool_exec_environment_variables
+        if agent_secrets:
+            agent_schema.tool_exec_environment_variables = {key: "" for key in agent_secrets}
+            agent_schema.secrets = {key: "" for key in agent_secrets}
 
         if agent_schema.messages:
             for message in agent_schema.messages:
@@ -655,10 +657,16 @@ class AgentSerializationManager:
                 if agent_data.get("source_ids"):
                     agent_data["source_ids"] = [file_to_db_ids[file_id] for file_id in agent_data["source_ids"]]
 
-                if env_vars and agent_data.get("tool_exec_environment_variables"):
+                if env_vars and agent_data.get("secrets"):
                     # update environment variable values from the provided env_vars dict
+                    for key in agent_data["secrets"]:
+                        agent_data["secrets"][key] = env_vars.get(key, "")
+                        agent_data["tool_exec_environment_variables"][key] = env_vars.get(key, "")
+                elif env_vars and agent_data.get("tool_exec_environment_variables"):
+                    # also handle tool_exec_environment_variables for backwards compatibility
                     for key in agent_data["tool_exec_environment_variables"]:
                         agent_data["tool_exec_environment_variables"][key] = env_vars.get(key, "")
+                        agent_data["secrets"][key] = env_vars.get(key, "")
 
                 # Override project_id if provided
                 if project_id:

letta/services/archive_manager.py

@@ -87,6 +87,79 @@ class ArchiveManager:
             )
             return archive.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def update_archive_async(
+        self,
+        archive_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        actor: PydanticUser = None,
+    ) -> PydanticArchive:
+        """Update archive name and/or description."""
+        async with db_registry.async_session() as session:
+            archive = await ArchiveModel.read_async(
+                db_session=session,
+                identifier=archive_id,
+                actor=actor,
+                check_is_deleted=True,
+            )
+
+            if name is not None:
+                archive.name = name
+            if description is not None:
+                archive.description = description
+
+            await archive.update_async(session, actor=actor)
+            return archive.to_pydantic()
+
+    @enforce_types
+    @trace_method
+    async def list_archives_async(
+        self,
+        *,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = False,
+        name: Optional[str] = None,
+        agent_id: Optional[str] = None,
+    ) -> List[PydanticArchive]:
+        """List archives with pagination and optional filters.
+
+        Filters:
+        - name: exact match on name
+        - agent_id: only archives attached to given agent
+        """
+        filter_kwargs = {}
+        if name is not None:
+            filter_kwargs["name"] = name
+
+        join_model = None
+        join_conditions = None
+        if agent_id is not None:
+            join_model = ArchivesAgents
+            join_conditions = [
+                ArchivesAgents.archive_id == ArchiveModel.id,
+                ArchivesAgents.agent_id == agent_id,
+            ]
+
+        async with db_registry.async_session() as session:
+            archives = await ArchiveModel.list_async(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                ascending=ascending,
+                actor=actor,
+                check_is_deleted=True,
+                join_model=join_model,
+                join_conditions=join_conditions,
+                **filter_kwargs,
+            )
+            return [a.to_pydantic() for a in archives]
+
     @enforce_types
     @trace_method
     def attach_agent_to_archive(

letta/services/file_manager.py

@@ -404,8 +404,10 @@ class FileManager:
         self,
         source_id: str,
         actor: PydanticUser,
+        before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
+        ascending: Optional[bool] = True,
         include_content: bool = False,
         strip_directory_prefix: bool = False,
         check_status_updates: bool = False,
@@ -415,8 +417,10 @@ class FileManager:
         Args:
             source_id: Source to list files from
             actor: User performing the request
+            before: Before filter
             after: Pagination cursor
             limit: Maximum number of files to return
+            ascending: Sort by ascending or descending order
             include_content: Whether to include file content
             strip_directory_prefix: Whether to strip directory prefix from filenames
             check_status_updates: Whether to check and update status for timeout and embedding completion
@@ -429,8 +433,10 @@ class FileManager:
 
             files = await FileMetadataModel.list_async(
                 db_session=session,
+                before=before,
                 after=after,
                 limit=limit,
+                ascending=ascending,
                 organization_id=actor.organization_id,
                 source_id=source_id,
                 query_options=options,

letta/services/group_manager.py

@@ -29,6 +29,7 @@ class GroupManager:
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
+        ascending: bool = True,
         show_hidden_groups: Optional[bool] = None,
     ) -> list[PydanticGroup]:
         async with db_registry.async_session() as session:
@@ -50,7 +51,7 @@ class GroupManager:
                 query = query.where((GroupModel.hidden.is_(None)) | (GroupModel.hidden == False))
 
             # Apply pagination
-            query = await _apply_group_pagination_async(query, before, after, session, ascending=True)
+            query = await _apply_group_pagination_async(query, before, after, session, ascending=ascending)
 
             if limit:
                 query = query.limit(limit)

letta/services/helpers/agent_manager_helper.py

@@ -29,7 +29,6 @@ from letta.orm.errors import NoResultFound
 from letta.orm.identity import Identity
 from letta.orm.passage import ArchivalPassage, SourcePassage
 from letta.orm.sources_agents import SourcesAgents
-from letta.orm.sqlite_functions import adapt_array
 from letta.otel.tracing import trace_method
 from letta.prompts import gpt_system
 from letta.prompts.prompt_generator import PromptGenerator
@@ -921,6 +920,8 @@ async def build_passage_query(
             main_query = main_query.order_by(combined_query.c.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             main_query = main_query.order_by(
                 func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
@@ -1054,6 +1055,8 @@ async def build_source_passage_query(
             query = query.order_by(SourcePassage.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             query = query.order_by(
                 func.cosine_distance(SourcePassage.embedding, query_embedding_binary).asc(),
@@ -1151,6 +1154,8 @@ async def build_agent_passage_query(
             query = query.order_by(ArchivalPassage.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             query = query.order_by(
                 func.cosine_distance(ArchivalPassage.embedding, query_embedding_binary).asc(),

letta/services/identity_manager.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import List, Optional
 
 from fastapi import HTTPException
@@ -9,6 +10,8 @@ from letta.orm.block import Block as BlockModel
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.orm.identity import Identity as IdentityModel
 from letta.otel.tracing import trace_method
+from letta.schemas.agent import AgentState
+from letta.schemas.block import Block
 from letta.schemas.identity import (
     Identity as PydanticIdentity,
     IdentityCreate,
@@ -35,6 +38,7 @@ class IdentityManager:
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
+        ascending: bool = False,
         actor: PydanticUser = None,
     ) -> list[PydanticIdentity]:
         async with db_registry.async_session() as session:
@@ -51,6 +55,7 @@ class IdentityManager:
                 before=before,
                 after=after,
                 limit=limit,
+                ascending=ascending,
                 **filters,
             )
             return [identity.to_pydantic() for identity in identities]
@@ -272,3 +277,65 @@ class IdentityManager:
             current_ids = {item.id for item in current_relationship}
             new_items = [item for item in found_items if item.id not in current_ids]
             current_relationship.extend(new_items)
+
+    @enforce_types
+    @trace_method
+    async def list_agents_for_identity_async(
+        self,
+        identity_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = False,
+        actor: PydanticUser = None,
+    ) -> List[AgentState]:
+        """
+        Get all agents associated with the specified identity.
+        """
+        async with db_registry.async_session() as session:
+            # First verify the identity exists and belongs to the user
+            identity = await IdentityModel.read_async(db_session=session, identifier=identity_id, actor=actor)
+            if identity is None:
+                raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
+
+            # Get agents associated with this identity with pagination
+            agents = await AgentModel.list_async(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                ascending=ascending,
+                identity_id=identity.id,
+            )
+            return await asyncio.gather(*[agent.to_pydantic_async() for agent in agents])
+
+    @enforce_types
+    @trace_method
+    async def list_blocks_for_identity_async(
+        self,
+        identity_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = False,
+        actor: PydanticUser = None,
+    ) -> List[Block]:
+        """
+        Get all blocks associated with the specified identity.
+        """
+        async with db_registry.async_session() as session:
+            # First verify the identity exists and belongs to the user
+            identity = await IdentityModel.read_async(db_session=session, identifier=identity_id, actor=actor)
+            if identity is None:
+                raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
+
+            # Get blocks associated with this identity with pagination
+            blocks = await BlockModel.list_async(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                ascending=ascending,
+                identity_id=identity.id,
+            )
+            return [block.to_pydantic() for block in blocks]

letta/services/job_manager.py

@@ -18,6 +18,7 @@ from letta.otel.tracing import log_event, trace_method
 from letta.schemas.enums import JobStatus, JobType, MessageRole
 from letta.schemas.job import BatchJob as PydanticBatchJob, Job as PydanticJob, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.run import Run as PydanticRun
 from letta.schemas.step import Step as PydanticStep
@@ -207,7 +208,12 @@ class JobManager:
     @enforce_types
     @trace_method
     async def safe_update_job_status_async(
-        self, job_id: str, new_status: JobStatus, actor: PydanticUser, metadata: Optional[dict] = None
+        self,
+        job_id: str,
+        new_status: JobStatus,
+        actor: PydanticUser,
+        stop_reason: Optional[StopReasonType] = None,
+        metadata: Optional[dict] = None,
     ) -> bool:
         """
         Safely update job status with state transition guards.
@@ -217,7 +223,7 @@ class JobManager:
             True if update was successful, False if update was skipped due to invalid transition
         """
         try:
-            job_update_builder = partial(JobUpdate, status=new_status)
+            job_update_builder = partial(JobUpdate, status=new_status, stop_reason=stop_reason)
 
             # If metadata is provided, merge it with existing metadata
             if metadata:
@@ -268,6 +274,7 @@ class JobManager:
         statuses: Optional[List[JobStatus]] = None,
         job_type: JobType = JobType.JOB,
         ascending: bool = True,
+        stop_reason: Optional[StopReasonType] = None,
     ) -> List[PydanticJob]:
         """List all jobs with optional pagination and status filter."""
         with db_registry.session() as session:
@@ -277,6 +284,10 @@ class JobManager:
             if statuses:
                 filter_kwargs["status"] = statuses
 
+            # Add stop_reason filter if provided
+            if stop_reason is not None:
+                filter_kwargs["stop_reason"] = stop_reason
+
             jobs = JobModel.list(
                 db_session=session,
                 before=before,
@@ -299,6 +310,7 @@ class JobManager:
         job_type: JobType = JobType.JOB,
         ascending: bool = True,
         source_id: Optional[str] = None,
+        stop_reason: Optional[StopReasonType] = None,
     ) -> List[PydanticJob]:
         """List all jobs with optional pagination and status filter."""
         from sqlalchemy import and_, or_, select
@@ -317,6 +329,10 @@ class JobManager:
                 column = column.op("->>")("source_id")
                 query = query.where(column == source_id)
 
+            # add stop_reason filter if provided
+            if stop_reason is not None:
+                query = query.where(JobModel.stop_reason == stop_reason)
+
             # handle cursor-based pagination
             if before or after:
                 # get cursor objects