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

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

@@ -12,10 +12,18 @@ from pydantic import BaseModel, Field
 from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
+from letta.agents.agent_loop import AgentLoop
 from letta.agents.letta_agent import LettaAgent
+from letta.agents.letta_agent_v2 import LettaAgentV2
 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 +47,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
@@ -52,7 +60,7 @@ from letta.server.server import SyncServer
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.telemetry_manager import NoopTelemetryManager
 from letta.settings import settings
-from letta.utils import safe_create_task, truncate_file_visible_content
+from letta.utils import safe_create_shielded_task, safe_create_task, truncate_file_visible_content
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -1013,7 +1021,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 +1035,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}.")
@@ -1138,7 +1146,9 @@ async def send_message(
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent = await server.agent_manager.get_agent_by_id_async(
+        agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+    )
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in [
         "anthropic",
@@ -1184,42 +1194,11 @@ async def send_message(
 
     try:
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    group=agent.multi_agent_group,
-                    current_run_id=run.id if run else None,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    current_run_id=run.id if run else None,
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
             result = await agent_loop.step(
                 request.messages,
                 max_steps=request.max_steps,
+                run_id=run.id if run else None,
                 use_assistant_message=request.use_assistant_message,
                 request_start_timestamp_ns=request_start_timestamp_ns,
                 include_return_message_types=request.include_return_message_types,
@@ -1239,6 +1218,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
@@ -1287,7 +1272,9 @@ async def send_message_streaming(
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent = await server.agent_manager.get_agent_by_id_async(
+        agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+    )
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in [
         "anthropic",
@@ -1332,57 +1319,16 @@ async def send_message_streaming(
 
     try:
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    group=agent.multi_agent_group,
-                    current_run_id=run.id if run else None,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    current_run_id=run.id if run else None,
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
-            if request.stream_tokens and model_compatible_token_streaming:
-                raw_stream = agent_loop.step_stream(
-                    input_messages=request.messages,
-                    max_steps=request.max_steps,
-                    use_assistant_message=request.use_assistant_message,
-                    request_start_timestamp_ns=request_start_timestamp_ns,
-                    include_return_message_types=request.include_return_message_types,
-                )
-            else:
-                raw_stream = agent_loop.step_stream_no_tokens(
-                    request.messages,
-                    max_steps=request.max_steps,
-                    use_assistant_message=request.use_assistant_message,
-                    request_start_timestamp_ns=request_start_timestamp_ns,
-                    include_return_message_types=request.include_return_message_types,
-                )
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
+            raw_stream = agent_loop.stream(
+                input_messages=request.messages,
+                max_steps=request.max_steps,
+                stream_tokens=request.stream_tokens and model_compatible_token_streaming,
+                run_id=run.id if run else None,
+                use_assistant_message=request.use_assistant_message,
+                request_start_timestamp_ns=request_start_timestamp_ns,
+                include_return_message_types=request.include_return_message_types,
+            )
 
             from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode, add_keepalive_to_stream
 
@@ -1397,12 +1343,13 @@ async def send_message_streaming(
                         ),
                     )
 
-                asyncio.create_task(
+                safe_create_task(
                     create_background_stream_processor(
                         stream_generator=raw_stream,
                         redis_client=redis_client,
                         run_id=run.id,
-                    )
+                    ),
+                    label=f"background_stream_processor_{run.id}",
                 )
 
                 raw_stream = redis_sse_stream_generator(
@@ -1437,6 +1384,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 +1452,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,
@@ -1513,7 +1503,9 @@ async def _process_message_background(
     """Background task to process the message and update job status."""
     request_start_timestamp_ns = get_utc_timestamp_ns()
     try:
-        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+        agent = await server.agent_manager.get_agent_by_id_async(
+            agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+        )
         agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
         model_compatible = agent.llm_config.model_endpoint_type in [
             "anthropic",
@@ -1529,37 +1521,7 @@ async def _process_message_background(
             "deepseek",
         ]
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    group=agent.multi_agent_group,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
             result = await agent_loop.step(
                 messages,
                 max_steps=max_steps,
@@ -1590,6 +1552,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(
@@ -1639,8 +1609,8 @@ 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(
+    # Create asyncio task for background processing (shielded to prevent cancellation)
+    task = safe_create_shielded_task(
         _process_message_background(
             run_id=run.id,
             server=server,
@@ -1652,9 +1622,34 @@ async def send_message_async(
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
             max_steps=request.max_steps,
             include_return_message_types=request.include_return_message_types,
-        )
+        ),
+        label=f"process_message_background_{run.id}",
     )
 
+    def handle_task_completion(t):
+        try:
+            t.result()
+        except asyncio.CancelledError:
+            # Note: With shielded tasks, cancellation attempts don't actually stop the task
+            logger.info(f"Cancellation attempted on shielded background task for run {run.id}, but task continues running")
+            # Don't mark as failed since the shielded task is still running
+        except Exception as e:
+            logger.error(f"Unhandled exception in background task for run {run.id}: {e}")
+            safe_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,
+                ),
+                label=f"update_failed_job_{run.id}",
+            )
+
+    task.add_done_callback(handle_task_completion)
+
     return run
 
 
@@ -1721,38 +1716,10 @@ async def preview_raw_payload(
     ]
 
     if agent_eligible and model_compatible:
-        if agent.enable_sleeptime:
-            # TODO: @caren need to support this for sleeptime
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Payload inspection is not supported for agents with sleeptime enabled.",
-            )
-        else:
-            agent_loop = LettaAgent(
-                agent_id=agent_id,
-                message_manager=server.message_manager,
-                agent_manager=server.agent_manager,
-                block_manager=server.block_manager,
-                job_manager=server.job_manager,
-                passage_manager=server.passage_manager,
-                actor=actor,
-                step_manager=server.step_manager,
-                telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                summarizer_mode=(
-                    SummarizationMode.STATIC_MESSAGE_BUFFER
-                    if agent.agent_type == AgentType.voice_convo_agent
-                    else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                ),
-            )
-
-        # TODO: Support step_streaming
-        return await agent_loop.step(
+        agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
+        return await agent_loop.build_request(
             input_messages=request.messages,
-            use_assistant_message=request.use_assistant_message,
-            include_return_message_types=request.include_return_message_types,
-            dry_run=True,
         )
-
     else:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -1793,19 +1760,14 @@ async def summarize_agent_conversation(
     ]
 
     if agent_eligible and model_compatible:
-        agent = LettaAgent(
-            agent_id=agent_id,
-            message_manager=server.message_manager,
-            agent_manager=server.agent_manager,
-            block_manager=server.block_manager,
-            job_manager=server.job_manager,
-            passage_manager=server.passage_manager,
-            actor=actor,
-            step_manager=server.step_manager,
-            telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-            message_buffer_min=max_message_length,
+        agent_loop = LettaAgentV2(agent_state=agent, actor=actor)
+        in_context_messages = await server.message_manager.get_messages_by_ids_async(message_ids=agent.message_ids, actor=actor)
+        await agent_loop.summarize_conversation_history(
+            in_context_messages=in_context_messages,
+            new_letta_messages=[],
+            total_tokens=None,
+            force=True,
         )
-        await agent.summarize_conversation_history()
         # Summarization completed, return 204 No Content
     else:
         raise HTTPException(

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)
 
@@ -320,7 +327,7 @@ async def upload_file_to_folder(
         logger=logger,
         label="file_processor.process",
     )
-    safe_create_task(sleeptime_document_ingest_async(server, folder_id, actor), logger=logger, label="sleeptime_document_ingest_async")
+    safe_create_task(sleeptime_document_ingest_async(server, folder_id, actor), label="sleeptime_document_ingest_async")
 
     return file_metadata
 
@@ -450,11 +457,17 @@ 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)
 
-    asyncio.create_task(sleeptime_document_ingest_async(server, folder_id, actor, clear_history=True))
+    safe_create_task(sleeptime_document_ingest_async(server, folder_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.")
 
@@ -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,
     )