letta-nightly 0.11.7.dev20250909104137__py3-none-any.whl → 0.11.7.dev20250911104039__py3-none-any.whl

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)

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

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Annotated, List, Optional
+from typing import Annotated, List, Literal, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 from pydantic import Field
@@ -14,7 +14,11 @@ from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
 from letta.schemas.step import Step
 from letta.server.rest_api.redis_stream_manager import redis_sse_stream_generator
-from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode, add_keepalive_to_stream
+from letta.server.rest_api.streaming_response import (
+    StreamingResponseWithStatusCode,
+    add_keepalive_to_stream,
+    cancellation_aware_stream_wrapper,
+)
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.settings import settings
@@ -115,33 +119,18 @@ async def list_run_messages(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    before: Optional[str] = Query(None, description="Cursor for pagination"),
-    after: Optional[str] = Query(None, description="Cursor for pagination"),
+    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: str = Query(
-        "asc", description="Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order."
+    order: Literal["asc", "desc"] = Query(
+        "asc", description="Sort order for messages by creation time. 'asc' for oldest first, 'desc' for newest first"
     ),
-    role: Optional[MessageRole] = Query(None, description="Filter by role"),
 ):
-    """
-    Get messages associated with a run with filtering options.
-
-    Args:
-        run_id: ID of the run
-        before: A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
-        after: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
-        limit: Maximum number of messages to return
-        order: Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
-        role: Filter by role (user/assistant/system/tool)
-        return_message_object: Whether to return Message objects or LettaMessage objects
-        user_id: ID of the user making the request
-
-    Returns:
-        A list of messages associated with the run. Default is List[LettaMessage].
-    """
-    if order not in ["asc", "desc"]:
-        raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
-
+    """Get response messages associated with a run."""
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
@@ -152,7 +141,6 @@ async def list_run_messages(
             before=before,
             after=after,
             ascending=(order == "asc"),
-            role=role,
         )
         return messages
     except NoResultFound as e:
@@ -251,7 +239,26 @@ async def delete_run(
         200: {
             "description": "Successful response",
             "content": {
-                "text/event-stream": {"description": "Server-Sent Events stream"},
+                # Align streaming schema with agents.create_stream so SDKs accept approval messages
+                "text/event-stream": {
+                    "description": "Server-Sent Events stream",
+                    "schema": {
+                        "oneOf": [
+                            {"$ref": "#/components/schemas/SystemMessage"},
+                            {"$ref": "#/components/schemas/UserMessage"},
+                            {"$ref": "#/components/schemas/ReasoningMessage"},
+                            {"$ref": "#/components/schemas/HiddenReasoningMessage"},
+                            {"$ref": "#/components/schemas/ToolCallMessage"},
+                            {"$ref": "#/components/schemas/ToolReturnMessage"},
+                            {"$ref": "#/components/schemas/AssistantMessage"},
+                            {"$ref": "#/components/schemas/ApprovalRequestMessage"},
+                            {"$ref": "#/components/schemas/ApprovalResponseMessage"},
+                            {"$ref": "#/components/schemas/LettaPing"},
+                            {"$ref": "#/components/schemas/LettaStopReason"},
+                            {"$ref": "#/components/schemas/LettaUsageStatistics"},
+                        ]
+                    },
+                },
             },
         }
     },
@@ -296,6 +303,14 @@ async def retrieve_stream(
         batch_size=request.batch_size,
     )
 
+    if settings.enable_cancellation_aware_streaming:
+        stream = cancellation_aware_stream_wrapper(
+            stream_generator=stream,
+            job_manager=server.job_manager,
+            job_id=run_id,
+            actor=actor,
+        )
+
     if request.include_pings and settings.enable_keepalive:
         stream = add_keepalive_to_stream(stream, keepalive_interval=settings.keepalive_interval)
 

letta/server/rest_api/routers/v1/sources.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
@@ -189,7 +190,13 @@ async def delete_source(
     files = await server.file_manager.list_files(source_id, actor)
     file_ids = [f.id for f in files]
 
-    if should_use_pinecone():
+    if should_use_tpuf():
+        logger.info(f"Deleting source {source_id} from Turbopuffer")
+        from letta.helpers.tpuf_client import TurbopufferClient
+
+        tpuf_client = TurbopufferClient()
+        await tpuf_client.delete_source_passages(source_id=source_id, organization_id=actor.organization_id)
+    elif should_use_pinecone():
         logger.info(f"Deleting source {source_id} from pinecone index")
         await delete_source_records_from_pinecone_index(source_id=source_id, actor=actor)
 
@@ -318,7 +325,7 @@ async def upload_file_to_source(
         logger=logger,
         label="file_processor.process",
     )
-    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), logger=logger, label="sleeptime_document_ingest_async")
+    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), label="sleeptime_document_ingest_async")
 
     return file_metadata
 
@@ -435,11 +442,17 @@ async def delete_file_from_source(
 
     await server.remove_file_from_context_windows(source_id=source_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=source_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)
 
-    asyncio.create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True))
+    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True), label="document_ingest_after_delete")
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 
@@ -481,10 +494,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/tools.py

@@ -587,6 +587,48 @@ async def list_mcp_tools_by_server(
         return mcp_tools
 
 
+@router.post("/mcp/servers/{mcp_server_name}/resync", operation_id="resync_mcp_server_tools")
+async def resync_mcp_server_tools(
+    mcp_server_name: str,
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    agent_id: Optional[str] = None,
+):
+    """
+    Resync tools for an MCP server by:
+    1. Fetching current tools from the MCP server
+    2. Deleting tools that no longer exist on the server
+    3. Updating schemas for existing tools
+    4. Adding new tools from the server
+
+    Returns a summary of changes made.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+    try:
+        result = await server.mcp_manager.resync_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor, agent_id=agent_id)
+        return result
+    except ValueError as e:
+        raise HTTPException(
+            status_code=404,
+            detail={
+                "code": "MCPServerNotFoundError",
+                "message": str(e),
+                "mcp_server_name": mcp_server_name,
+            },
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error refreshing MCP server tools: {e}")
+        raise HTTPException(
+            status_code=404,
+            detail={
+                "code": "MCPRefreshError",
+                "message": f"Failed to refresh MCP server tools: {str(e)}",
+                "mcp_server_name": mcp_server_name,
+            },
+        )
+
+
 @router.post("/mcp/servers/{mcp_server_name}/{mcp_tool_name}", response_model=Tool, operation_id="add_mcp_tool")
 async def add_mcp_tool(
     mcp_server_name: str,

letta/server/rest_api/streaming_response.py

@@ -7,10 +7,11 @@ import json
 from collections.abc import AsyncIterator
 
 import anyio
+from fastapi import HTTPException
 from fastapi.responses import StreamingResponse
 from starlette.types import Send
 
-from letta.errors import LettaUnexpectedStreamCancellationError
+from letta.errors import LettaUnexpectedStreamCancellationError, PendingApprovalError
 from letta.log import get_logger
 from letta.schemas.enums import JobStatus
 from letta.schemas.letta_ping import LettaPing
@@ -18,6 +19,7 @@ from letta.schemas.user import User
 from letta.server.rest_api.utils import capture_sentry_exception
 from letta.services.job_manager import JobManager
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -63,7 +65,7 @@ async def add_keepalive_to_stream(
             await queue.put(("end", None))
 
     # Start the stream reader task
-    reader_task = asyncio.create_task(stream_reader())
+    reader_task = safe_create_task(stream_reader(), label="stream_reader")
 
     try:
         while True:
@@ -189,6 +191,13 @@ class StreamingResponseWithStatusCode(StreamingResponse):
             except anyio.ClosedResourceError:
                 logger.info("Client disconnected, but shielded task should continue")
                 self._client_connected = False
+            except PendingApprovalError as e:
+                # This is an expected error, don't log as error
+                logger.info(f"Pending approval conflict in stream response: {e}")
+                # Re-raise as HTTPException for proper client handling
+                raise HTTPException(
+                    status_code=409, detail={"code": "PENDING_APPROVAL", "message": str(e), "pending_request_id": e.pending_request_id}
+                )
             except Exception as e:
                 logger.error(f"Error in protected stream response: {e}")
                 raise

letta/server/server.py

@@ -109,7 +109,7 @@ from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import DatabaseChoice, model_settings, settings, tool_settings
 from letta.streaming_interface import AgentChunkStreamingInterface
-from letta.utils import get_friendly_error_msg, get_persona_text, make_key
+from letta.utils import get_friendly_error_msg, get_persona_text, make_key, safe_create_task
 
 config = LettaConfig.load()
 logger = get_logger(__name__)
@@ -1125,7 +1125,8 @@ class SyncServer(Server):
             ascending=ascending,
             limit=limit,
         )
-        return records
+        # Extract just the passages (SQL path returns empty metadata)
+        return [passage for passage, _, _ in records]
 
     async def insert_archival_memory_async(
         self, agent_id: str, memory_contents: str, actor: User, tags: Optional[List[str]], created_at: Optional[datetime]
@@ -2247,7 +2248,7 @@ class SyncServer(Server):
 
             # Offload the synchronous message_func to a separate thread
             streaming_interface.stream_start()
-            task = asyncio.create_task(
+            task = safe_create_task(
                 asyncio.to_thread(
                     self.send_messages,
                     actor=actor,
@@ -2255,7 +2256,8 @@ class SyncServer(Server):
                     input_messages=input_messages,
                     interface=streaming_interface,
                     metadata=metadata,
-                )
+                ),
+                label="send_messages_thread",
             )
 
             if stream_steps:
@@ -2362,13 +2364,14 @@ class SyncServer(Server):
             streaming_interface.metadata = metadata
 
         streaming_interface.stream_start()
-        task = asyncio.create_task(
+        task = safe_create_task(
             asyncio.to_thread(
                 letta_multi_agent.step,
                 input_messages=input_messages,
                 chaining=self.chaining,
                 max_chaining_steps=self.max_chaining_steps,
-            )
+            ),
+            label="multi_agent_step_thread",
         )
 
         if stream_steps: