letta-nightly 0.11.7.dev20250908104137__py3-none-any.whl → 0.11.7.dev20250910104051__py3-none-any.whl

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

@@ -15,7 +15,13 @@ from starlette.responses import Response, StreamingResponse
 from letta.agents.letta_agent import LettaAgent
 from letta.constants import AGENT_ID_PATTERN, DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REDIS_RUN_ID_PREFIX
 from letta.data_sources.redis_client import NoopAsyncRedisClient, get_redis_client
-from letta.errors import AgentExportIdMappingError, AgentExportProcessingError, AgentFileImportError, AgentNotFoundForExportError
+from letta.errors import (
+    AgentExportIdMappingError,
+    AgentExportProcessingError,
+    AgentFileImportError,
+    AgentNotFoundForExportError,
+    PendingApprovalError,
+)
 from letta.groups.sleeptime_multi_agent_v2 import SleeptimeMultiAgentV2
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns
 from letta.log import get_logger
@@ -39,7 +45,7 @@ from letta.schemas.memory import (
     CreateArchivalMemory,
     Memory,
 )
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import MessageCreate, MessageSearchRequest, MessageSearchResult
 from letta.schemas.passage import Passage
 from letta.schemas.run import Run
 from letta.schemas.source import Source
@@ -1013,7 +1019,7 @@ async def search_archival_memory(
         end_datetime = end_datetime.isoformat() if end_datetime else None
 
         # Use the shared agent manager method
-        formatted_results, count = await server.agent_manager.search_agent_archival_memory_async(
+        formatted_results = await server.agent_manager.search_agent_archival_memory_async(
             agent_id=agent_id,
             actor=actor,
             query=query,
@@ -1027,7 +1033,7 @@ async def search_archival_memory(
         # Convert to proper response schema
         search_results = [ArchivalMemorySearchResult(**result) for result in formatted_results]
 
-        return ArchivalMemorySearchResponse(results=search_results, count=count)
+        return ArchivalMemorySearchResponse(results=search_results, count=len(formatted_results))
 
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
@@ -1239,6 +1245,12 @@ async def send_message(
             )
         job_status = result.stop_reason.stop_reason.run_status
         return result
+    except PendingApprovalError as e:
+        job_update_metadata = {"error": str(e)}
+        job_status = JobStatus.failed
+        raise HTTPException(
+            status_code=409, detail={"code": "PENDING_APPROVAL", "message": str(e), "pending_request_id": e.pending_request_id}
+        )
     except Exception as e:
         job_update_metadata = {"error": str(e)}
         job_status = JobStatus.failed
@@ -1437,6 +1449,13 @@ async def send_message_streaming(
         if settings.track_agent_run:
             job_status = JobStatus.running
         return result
+    except PendingApprovalError as e:
+        if settings.track_agent_run:
+            job_update_metadata = {"error": str(e)}
+            job_status = JobStatus.failed
+        raise HTTPException(
+            status_code=409, detail={"code": "PENDING_APPROVAL", "message": str(e), "pending_request_id": e.pending_request_id}
+        )
     except Exception as e:
         if settings.track_agent_run:
             job_update_metadata = {"error": str(e)}
@@ -1498,6 +1517,42 @@ async def cancel_agent_run(
     return results
 
 
+@router.post("/messages/search", response_model=List[MessageSearchResult], operation_id="search_messages")
+async def search_messages(
+    request: MessageSearchRequest = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: str | None = Header(None, alias="user_id"),
+):
+    """
+    Search messages across the entire organization with optional project and template filtering. Returns messages with FTS/vector ranks and total RRF score.
+
+    This is a cloud-only feature.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+    # get embedding config from the default agent if needed
+    # check if any agents exist in the org
+    agent_count = await server.agent_manager.size_async(actor=actor)
+    if agent_count == 0:
+        raise HTTPException(status_code=400, detail="No agents found in organization to derive embedding configuration from")
+
+    try:
+        results = await server.message_manager.search_messages_org_async(
+            actor=actor,
+            query_text=request.query,
+            search_mode=request.search_mode,
+            roles=request.roles,
+            project_id=request.project_id,
+            template_id=request.template_id,
+            limit=request.limit,
+            start_date=request.start_date,
+            end_date=request.end_date,
+        )
+        return results
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
 async def _process_message_background(
     run_id: str,
     server: SyncServer,
@@ -1590,6 +1645,14 @@ async def _process_message_background(
         )
         await server.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=actor)
 
+    except PendingApprovalError as e:
+        # Update job status to failed with specific error info
+        job_update = JobUpdate(
+            status=JobStatus.failed,
+            completed_at=datetime.now(timezone.utc),
+            metadata={"error": str(e), "error_code": "PENDING_APPROVAL", "pending_request_id": e.pending_request_id},
+        )
+        await server.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=actor)
     except Exception as e:
         # Update job status to failed
         job_update = JobUpdate(
@@ -1640,7 +1703,7 @@ async def send_message_async(
     run = await server.job_manager.create_job_async(pydantic_job=run, actor=actor)
 
     # Create asyncio task for background processing
-    asyncio.create_task(
+    task = asyncio.create_task(
         _process_message_background(
             run_id=run.id,
             server=server,
@@ -1655,6 +1718,38 @@ async def send_message_async(
         )
     )
 
+    def handle_task_completion(t):
+        try:
+            t.result()
+        except asyncio.CancelledError:
+            logger.error(f"Background task for run {run.id} was cancelled")
+            asyncio.create_task(
+                server.job_manager.update_job_by_id_async(
+                    job_id=run.id,
+                    job_update=JobUpdate(
+                        status=JobStatus.failed,
+                        completed_at=datetime.now(timezone.utc),
+                        metadata={"error": "Task was cancelled"},
+                    ),
+                    actor=actor,
+                )
+            )
+        except Exception as e:
+            logger.error(f"Unhandled exception in background task for run {run.id}: {e}")
+            asyncio.create_task(
+                server.job_manager.update_job_by_id_async(
+                    job_id=run.id,
+                    job_update=JobUpdate(
+                        status=JobStatus.failed,
+                        completed_at=datetime.now(timezone.utc),
+                        metadata={"error": str(e)},
+                    ),
+                    actor=actor,
+                )
+            )
+
+    task.add_done_callback(handle_task_completion)
+
     return run
 
 

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

@@ -68,6 +68,11 @@ async def list_blocks(
             "If provided, returns blocks that have exactly this number of connected agents."
         ),
     ),
+    show_hidden_blocks: bool | None = Query(
+        False,
+        include_in_schema=False,
+        description="If set to True, include blocks marked as hidden in the results.",
+    ),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -89,6 +94,7 @@ async def list_blocks(
         connected_to_agents_count_eq=connected_to_agents_count_eq,
         limit=limit,
         after=after,
+        show_hidden_blocks=show_hidden_blocks,
     )
 
 

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

@@ -15,6 +15,7 @@ from letta.helpers.pinecone_utils import (
     delete_source_records_from_pinecone_index,
     should_use_pinecone,
 )
+from letta.helpers.tpuf_client import should_use_tpuf
 from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
@@ -191,7 +192,13 @@ async def delete_folder(
     files = await server.file_manager.list_files(folder_id, actor)
     file_ids = [f.id for f in files]
 
-    if should_use_pinecone():
+    if should_use_tpuf():
+        logger.info(f"Deleting folder {folder_id} from Turbopuffer")
+        from letta.helpers.tpuf_client import TurbopufferClient
+
+        tpuf_client = TurbopufferClient()
+        await tpuf_client.delete_source_passages(source_id=folder_id, organization_id=actor.organization_id)
+    elif should_use_pinecone():
         logger.info(f"Deleting folder {folder_id} from pinecone index")
         await delete_source_records_from_pinecone_index(source_id=folder_id, actor=actor)
 
@@ -450,7 +457,13 @@ async def delete_file_from_folder(
 
     await server.remove_file_from_context_windows(source_id=folder_id, file_id=deleted_file.id, actor=actor)
 
-    if should_use_pinecone():
+    if should_use_tpuf():
+        logger.info(f"Deleting file {file_id} from Turbopuffer")
+        from letta.helpers.tpuf_client import TurbopufferClient
+
+        tpuf_client = TurbopufferClient()
+        await tpuf_client.delete_file_passages(source_id=folder_id, file_id=file_id, organization_id=actor.organization_id)
+    elif should_use_pinecone():
         logger.info(f"Deleting file {file_id} from pinecone index")
         await delete_file_records_from_pinecone_index(file_id=file_id, actor=actor)
 
@@ -496,10 +509,15 @@ async def load_file_to_source_cloud(
     else:
         file_parser = MarkitdownFileParser()
 
-    using_pinecone = should_use_pinecone()
-    if using_pinecone:
+    # determine which embedder to use - turbopuffer takes precedence
+    if should_use_tpuf():
+        from letta.services.file_processor.embedder.turbopuffer_embedder import TurbopufferEmbedder
+
+        embedder = TurbopufferEmbedder(embedding_config=embedding_config)
+    elif should_use_pinecone():
         embedder = PineconeEmbedder(embedding_config=embedding_config)
     else:
         embedder = OpenAIEmbedder(embedding_config=embedding_config)
-    file_processor = FileProcessor(file_parser=file_parser, embedder=embedder, actor=actor, using_pinecone=using_pinecone)
+
+    file_processor = FileProcessor(file_parser=file_parser, embedder=embedder, actor=actor)
     await file_processor.process(agent_states=agent_states, source_id=source_id, content=content, file_metadata=file_metadata)

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

@@ -25,6 +25,11 @@ async def list_groups(
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(None, description="Limit for pagination"),
     project_id: Optional[str] = Query(None, description="Search groups by project id"),
+    show_hidden_groups: bool | None = Query(
+        False,
+        include_in_schema=False,
+        description="If set to True, include groups marked as hidden in the results.",
+    ),
 ):
     """
     Fetch all multi-agent groups matching query.
@@ -37,6 +42,7 @@ async def list_groups(
         before=before,
         after=after,
         limit=limit,
+        show_hidden_groups=show_hidden_groups,
     )
 
 

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

@@ -1,6 +1,7 @@
-from typing import Optional
+from typing import List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from pydantic import BaseModel
 
 from letta.schemas.agent import AgentState, InternalTemplateAgentCreate
 from letta.schemas.block import Block, InternalTemplateBlockCreate
@@ -16,9 +17,6 @@ async def create_group(
     group: InternalTemplateGroupCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    x_project: Optional[str] = Header(
-        None, alias="X-Project", description="The project slug to associate with the group (cloud only)."
-    ),  # Only handled by next js middleware
 ):
     """
     Create a new multi-agent group with the specified configuration.
@@ -35,9 +33,6 @@ async def create_agent(
     agent: InternalTemplateAgentCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    x_project: Optional[str] = Header(
-        None, alias="X-Project", description="The project slug to associate with the agent (cloud only)."
-    ),  # Only handled by next js middleware
 ):
     """
     Create a new agent with template-related fields.
@@ -54,15 +49,226 @@ async def create_block(
     block: InternalTemplateBlockCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    x_project: Optional[str] = Header(
-        None, alias="X-Project", description="The project slug to associate with the block (cloud only)."
-    ),  # Only handled by next js middleware
 ):
     """
     Create a new block with template-related fields.
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        return await server.block_manager.create_or_update_block_async(block, actor=actor)
+        block_obj = Block(**block.model_dump())
+        return await server.block_manager.create_or_update_block_async(block_obj, actor=actor)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class DeploymentEntity(BaseModel):
+    """A deployment entity."""
+
+    id: str
+    type: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+class ListDeploymentEntitiesResponse(BaseModel):
+    """Response model for listing deployment entities."""
+
+    entities: List[DeploymentEntity] = []
+    total_count: int
+    deployment_id: str
+    message: str
+
+
+class DeleteDeploymentResponse(BaseModel):
+    """Response model for delete deployment operation."""
+
+    deleted_blocks: List[str] = []
+    deleted_agents: List[str] = []
+    deleted_groups: List[str] = []
+    message: str
+
+
+@router.get("/deployment/{deployment_id}", response_model=ListDeploymentEntitiesResponse, operation_id="list_deployment_entities")
+async def list_deployment_entities(
+    deployment_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    entity_types: Optional[List[str]] = Query(None, description="Filter by entity types (block, agent, group)"),
+):
+    """
+    List all entities (blocks, agents, groups) with the specified deployment_id.
+    Optionally filter by entity types.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+        entities = []
+
+        # Parse entity_types filter - support both array and comma-separated string
+        allowed_types = {"block", "agent", "group"}
+        if entity_types is None:
+            # If no filter specified, include all types
+            types_to_include = allowed_types
+        else:
+            # Handle comma-separated strings in a single item
+            if len(entity_types) == 1 and "," in entity_types[0]:
+                entity_types = [t.strip() for t in entity_types[0].split(",")]
+
+            # Validate and filter types
+            types_to_include = {t.lower() for t in entity_types if t.lower() in allowed_types}
+            if not types_to_include:
+                types_to_include = allowed_types  # Default to all if invalid types provided
+
+        # Query blocks if requested
+        if "block" in types_to_include:
+            from sqlalchemy import select
+
+            from letta.orm.block import Block as BlockModel
+            from letta.server.db import db_registry
+
+            async with db_registry.async_session() as session:
+                block_query = select(BlockModel).where(
+                    BlockModel.deployment_id == deployment_id, BlockModel.organization_id == actor.organization_id
+                )
+                result = await session.execute(block_query)
+                blocks = result.scalars().all()
+
+                for block in blocks:
+                    entities.append(
+                        DeploymentEntity(
+                            id=block.id,
+                            type="block",
+                            name=getattr(block, "template_name", None) or getattr(block, "label", None),
+                            description=block.description,
+                        )
+                    )
+
+        # Query agents if requested
+        if "agent" in types_to_include:
+            from letta.orm.agent import Agent as AgentModel
+
+            async with db_registry.async_session() as session:
+                agent_query = select(AgentModel).where(
+                    AgentModel.deployment_id == deployment_id, AgentModel.organization_id == actor.organization_id
+                )
+                result = await session.execute(agent_query)
+                agents = result.scalars().all()
+
+                for agent in agents:
+                    entities.append(DeploymentEntity(id=agent.id, type="agent", name=agent.name, description=agent.description))
+
+        # Query groups if requested
+        if "group" in types_to_include:
+            from letta.orm.group import Group as GroupModel
+
+            async with db_registry.async_session() as session:
+                group_query = select(GroupModel).where(
+                    GroupModel.deployment_id == deployment_id, GroupModel.organization_id == actor.organization_id
+                )
+                result = await session.execute(group_query)
+                groups = result.scalars().all()
+
+                for group in groups:
+                    entities.append(
+                        DeploymentEntity(
+                            id=group.id,
+                            type="group",
+                            name=None,  # Groups don't have a name field
+                            description=group.description,
+                        )
+                    )
+
+        message = f"Found {len(entities)} entities for deployment {deployment_id}"
+        if entity_types:
+            message += f" (filtered by types: {', '.join(types_to_include)})"
+
+        return ListDeploymentEntitiesResponse(entities=entities, total_count=len(entities), deployment_id=deployment_id, message=message)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/deployment/{deployment_id}", response_model=DeleteDeploymentResponse, operation_id="delete_deployment")
+async def delete_deployment(
+    deployment_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Delete all entities (blocks, agents, groups) with the specified deployment_id.
+    Deletion order: blocks -> agents -> groups to maintain referential integrity.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+        deleted_blocks = []
+        deleted_agents = []
+        deleted_groups = []
+
+        # First delete blocks
+        from sqlalchemy import select
+
+        from letta.orm.block import Block as BlockModel
+        from letta.server.db import db_registry
+
+        async with db_registry.async_session() as session:
+            # Get all blocks with the deployment_id
+            block_query = select(BlockModel).where(
+                BlockModel.deployment_id == deployment_id, BlockModel.organization_id == actor.organization_id
+            )
+            result = await session.execute(block_query)
+            blocks = result.scalars().all()
+
+            for block in blocks:
+                try:
+                    await server.block_manager.delete_block_async(block.id, actor)
+                    deleted_blocks.append(block.id)
+                except Exception as e:
+                    # Continue deleting other blocks even if one fails
+                    print(f"Failed to delete block {block.id}: {e}")
+
+        # Then delete agents
+        from letta.orm.agent import Agent as AgentModel
+
+        async with db_registry.async_session() as session:
+            # Get all agents with the deployment_id
+            agent_query = select(AgentModel).where(
+                AgentModel.deployment_id == deployment_id, AgentModel.organization_id == actor.organization_id
+            )
+            result = await session.execute(agent_query)
+            agents = result.scalars().all()
+
+            for agent in agents:
+                try:
+                    await server.agent_manager.delete_agent_async(agent.id, actor)
+                    deleted_agents.append(agent.id)
+                except Exception as e:
+                    # Continue deleting other agents even if one fails
+                    print(f"Failed to delete agent {agent.id}: {e}")
+
+        # Finally delete groups
+        from letta.orm.group import Group as GroupModel
+
+        async with db_registry.async_session() as session:
+            # Get all groups with the deployment_id
+            group_query = select(GroupModel).where(
+                GroupModel.deployment_id == deployment_id, GroupModel.organization_id == actor.organization_id
+            )
+            result = await session.execute(group_query)
+            groups = result.scalars().all()
+
+            for group in groups:
+                try:
+                    await server.group_manager.delete_group_async(group.id, actor)
+                    deleted_groups.append(group.id)
+                except Exception as e:
+                    # Continue deleting other groups even if one fails
+                    print(f"Failed to delete group {group.id}: {e}")
+
+        total_deleted = len(deleted_blocks) + len(deleted_agents) + len(deleted_groups)
+        message = f"Successfully deleted {total_deleted} entities from deployment {deployment_id}"
+
+        return DeleteDeploymentResponse(
+            deleted_blocks=deleted_blocks, deleted_agents=deleted_agents, deleted_groups=deleted_groups, message=message
+        )
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

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

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, Query
 from fastapi.exceptions import HTTPException
@@ -25,9 +25,9 @@ logger = get_logger(__name__)
 @router.post(
     "/batches",
     response_model=BatchJob,
-    operation_id="create_messages_batch",
+    operation_id="create_batch_run",
 )
-async def create_messages_batch(
+async def create_batch_run(
     request: Request,
     payload: CreateBatch = Body(..., description="Messages and config for all agents"),
     server: SyncServer = Depends(get_letta_server),
@@ -127,25 +127,21 @@ async def list_batch_runs(
 )
 async def list_batch_messages(
     batch_id: str,
-    limit: int = Query(100, description="Maximum number of messages to return"),
-    cursor: Optional[str] = Query(
-        None, description="Message ID to use as pagination cursor (get messages before/after this ID) depending on sort_descending."
+    before: Optional[str] = Query(
+        None, description="Message ID cursor for pagination. Returns messages that come before this message ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Message ID cursor for pagination. Returns messages that come after this message ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for messages by creation time. 'asc' for oldest first, 'desc' for newest first"
     ),
     agent_id: Optional[str] = Query(None, description="Filter messages by agent ID"),
-    sort_descending: bool = Query(True, description="Sort messages by creation time (true=newest first)"),
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: SyncServer = Depends(get_letta_server),
 ):
-    """
-    Get messages for a specific batch job.
-
-    Returns messages associated with the batch in chronological order.
-
-    Pagination:
-    - For the first page, omit the cursor parameter
-    - For subsequent pages, use the ID of the last message from the previous response as the cursor
-    - Results will include messages before/after the cursor based on sort_descending
-    """
+    """Get response messages for a specific batch job."""
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # First, verify the batch job exists and the user has access to it
@@ -156,9 +152,8 @@ async def list_batch_messages(
         raise HTTPException(status_code=404, detail="Batch not found")
 
     # Get messages directly using our efficient method
-    # We'll need to update the underlying implementation to use message_id as cursor
     messages = await server.batch_manager.get_messages_for_letta_batch_async(
-        letta_batch_job_id=batch_id, limit=limit, actor=actor, agent_id=agent_id, sort_descending=sort_descending, cursor=cursor
+        letta_batch_job_id=batch_id, limit=limit, actor=actor, agent_id=agent_id, ascending=(order == "asc"), before=before, after=after
     )
 
     return LettaBatchMessages(messages=messages)