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

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

@@ -38,6 +38,7 @@ from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion, MessageType
 from letta.schemas.letta_request import LettaAsyncRequest, LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.memory import (
     ArchivalMemorySearchResponse,
     ArchivalMemorySearchResult,
@@ -1192,6 +1193,7 @@ async def send_message(
     await redis_client.set(f"{REDIS_RUN_ID_PREFIX}:{agent_id}", run.id if run else None)
 
     try:
+        result = None
         if agent_eligible and model_compatible:
             agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
             result = await agent_loop.step(
@@ -1229,11 +1231,17 @@ async def send_message(
         raise
     finally:
         if settings.track_agent_run:
+            if result:
+                stop_reason = result.stop_reason.stop_reason
+            else:
+                # NOTE: we could also consider this an error?
+                stop_reason = None
             await server.job_manager.safe_update_job_status_async(
                 job_id=run.id,
                 new_status=job_status,
                 actor=actor,
                 metadata=job_update_metadata,
+                stop_reason=stop_reason,
             )
 
 
@@ -1440,10 +1448,7 @@ async def send_message_streaming(
     finally:
         if settings.track_agent_run:
             await server.job_manager.safe_update_job_status_async(
-                job_id=run.id,
-                new_status=job_status,
-                actor=actor,
-                metadata=job_update_metadata,
+                job_id=run.id, new_status=job_status, actor=actor, metadata=job_update_metadata
             )
 
 

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

@@ -0,0 +1,113 @@
+from typing import List, Literal, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from letta.orm.errors import NoResultFound
+from letta.schemas.archive import Archive as PydanticArchive
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/archives", tags=["archives"])
+
+
+class ArchiveCreateRequest(BaseModel):
+    """Request model for creating an archive.
+
+    Intentionally excludes vector_db_provider. These are derived internally (vector DB provider from env).
+    """
+
+    name: str
+    description: Optional[str] = None
+
+
+class ArchiveUpdateRequest(BaseModel):
+    """Request model for updating an archive (partial).
+
+    Supports updating only name and description.
+    """
+
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+@router.post("/", response_model=PydanticArchive, operation_id="create_archive")
+async def create_archive(
+    archive: ArchiveCreateRequest = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Create a new archive.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.archive_manager.create_archive_async(
+            name=archive.name,
+            description=archive.description,
+            actor=actor,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/", response_model=List[PydanticArchive], operation_id="list_archives")
+async def list_archives(
+    before: Optional[str] = Query(
+        None,
+        description="Archive ID cursor for pagination. Returns archives that come before this archive ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Archive ID cursor for pagination. Returns archives that come after this archive ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of archives to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for archives by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    name: Optional[str] = Query(None, description="Filter by archive name (exact match)"),
+    agent_id: Optional[str] = Query(None, description="Only archives attached to this agent ID"),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a list of all archives for the current organization with optional filters and pagination.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        archives = await server.archive_manager.list_archives_async(
+            actor=actor,
+            before=before,
+            after=after,
+            limit=limit,
+            ascending=(order == "asc"),
+            name=name,
+            agent_id=agent_id,
+        )
+        return archives
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/{archive_id}", response_model=PydanticArchive, operation_id="modify_archive")
+async def modify_archive(
+    archive_id: str,
+    archive: ArchiveUpdateRequest = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Update an existing archive's name and/or description.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.archive_manager.update_archive_async(
+            archive_id=archive_id,
+            name=archive.name,
+            description=archive.description,
+            actor=actor,
+        )
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

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

@@ -19,18 +19,23 @@ async def list_jobs(
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(50, description="Limit for pagination"),
+    active: bool = Query(False, description="Filter for active jobs."),
     ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
     headers: HeaderParams = Depends(get_headers),
 ):
     """
     List all jobs.
-    TODO (cliandy): implementation for pagination
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
+    statuses = None
+    if active:
+        statuses = [JobStatus.created, JobStatus.running]
+
     # TODO: add filtering by status
     return await server.job_manager.list_jobs_async(
         actor=actor,
+        statuses=statuses,
         source_id=source_id,
         before=before,
         after=after,
@@ -39,7 +44,7 @@ async def list_jobs(
     )
 
 
-@router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
+@router.get("/active", response_model=List[Job], operation_id="list_active_jobs", deprecated=True)
 async def list_active_jobs(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),

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

@@ -10,6 +10,7 @@ from letta.orm.errors import NoResultFound
 from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import RetrieveStreamRequest
+from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
 from letta.schemas.step import Step
@@ -31,9 +32,11 @@ def list_runs(
     server: "SyncServer" = Depends(get_letta_server),
     agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),
     background: Optional[bool] = Query(None, description="If True, filters for runs that were created in background mode."),
+    stop_reason: Optional[StopReasonType] = Query(None, description="Filter runs by stop reason."),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(50, description="Maximum number of runs to return"),
+    active: bool = Query(False, description="Filter for active runs."),
     ascending: bool = Query(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default)",
@@ -44,16 +47,21 @@ def list_runs(
     List all runs.
     """
     actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
+    statuses = None
+    if active:
+        statuses = [JobStatus.created, JobStatus.running]
 
     runs = [
         Run.from_job(job)
         for job in server.job_manager.list_jobs(
             actor=actor,
+            statuses=statuses,
             job_type=JobType.RUN,
             limit=limit,
             before=before,
             after=after,
             ascending=False,
+            stop_reason=stop_reason,
         )
     ]
     if agent_ids:
@@ -63,7 +71,7 @@ def list_runs(
     return runs
 
 
-@router.get("/active", response_model=List[Run], operation_id="list_active_runs")
+@router.get("/active", response_model=List[Run], operation_id="list_active_runs", deprecated=True)
 def list_active_runs(
     server: "SyncServer" = Depends(get_letta_server),
     agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),

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

@@ -728,35 +728,16 @@ async def add_mcp_server_to_config(
             return await server.add_mcp_server_to_config(server_config=request, allow_upsert=True)
         else:
             # log to DB
-            from letta.schemas.mcp import MCPServer
-
-            if isinstance(request, StdioServerConfig):
-                mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
-                # don't allow stdio servers
-                if tool_settings.mcp_disable_stdio:  # protected server
-                    raise HTTPException(
-                        status_code=400,
-                        detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
-                    )
-            elif isinstance(request, SSEServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
-                )
-            elif isinstance(request, StreamableHTTPServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
+            # Check if stdio servers are disabled
+            if isinstance(request, StdioServerConfig) and tool_settings.mcp_disable_stdio:
+                raise HTTPException(
+                    status_code=400,
+                    detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
                 )
 
             # Create MCP server and optimistically sync tools
-            await server.mcp_manager.create_mcp_server_with_tools(mapped_request, actor=actor)
+            # The mcp_manager will handle encryption of sensitive fields
+            await server.mcp_manager.create_mcp_server_from_config_with_tools(request, actor=actor)
 
             # TODO: don't do this in the future (just return MCPServer)
             all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)

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/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/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