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

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)
 
@@ -435,7 +442,13 @@ 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)
 
@@ -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
@@ -189,6 +190,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

@@ -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]

letta/services/agent_manager.py

@@ -720,7 +720,7 @@ class AgentManager:
         # Only create messages if we initialized with messages
         if not _init_with_no_messages:
             await self.message_manager.create_many_messages_async(
-                pydantic_msgs=init_messages, actor=actor, embedding_config=result.embedding_config
+                pydantic_msgs=init_messages, actor=actor, project_id=result.project_id, template_id=result.template_id
             )
         return result
 
@@ -1834,6 +1834,7 @@ class AgentManager:
                     message_id=curr_system_message.id,
                     message_update=MessageUpdate(**temp_message.model_dump()),
                     actor=actor,
+                    project_id=agent_state.project_id,
                 )
             else:
                 curr_system_message = temp_message
@@ -1887,7 +1888,9 @@ class AgentManager:
         self, messages: List[PydanticMessage], agent_id: str, actor: PydanticUser
     ) -> PydanticAgentState:
         agent = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor)
-        messages = await self.message_manager.create_many_messages_async(messages, actor=actor, embedding_config=agent.embedding_config)
+        messages = await self.message_manager.create_many_messages_async(
+            messages, actor=actor, project_id=agent.project_id, template_id=agent.template_id
+        )
         message_ids = agent.message_ids or []
         message_ids += [m.id for m in messages]
         return await self.set_in_context_messages_async(agent_id=agent_id, message_ids=message_ids, actor=actor)
@@ -2655,7 +2658,7 @@ class AgentManager:
         embedding_config: Optional[EmbeddingConfig] = None,
         tags: Optional[List[str]] = None,
         tag_match_mode: Optional[TagMatchMode] = None,
-    ) -> List[PydanticPassage]:
+    ) -> List[Tuple[PydanticPassage, float, dict]]:
         """Lists all passages attached to an agent."""
         # Check if we should use Turbopuffer for vector search
         if embed_query and agent_id and query_text and embedding_config:
@@ -2688,7 +2691,6 @@ class AgentManager:
                     # use hybrid search to combine vector and full-text search
                     passages_with_scores = await tpuf_client.query_passages(
                         archive_id=archive_ids[0],
-                        query_embedding=query_embedding,
                         query_text=query_text,  # pass text for potential hybrid search
                         search_mode="hybrid",  # use hybrid mode for better results
                         top_k=limit,
@@ -2696,10 +2698,11 @@ class AgentManager:
                         tag_match_mode=tag_match_mode or TagMatchMode.ANY,
                         start_date=start_date,
                         end_date=end_date,
+                        actor=actor,
                     )
 
-                    # Return just the passages (without scores)
-                    return [passage for passage, _ in passages_with_scores]
+                    # Return full tuples with metadata
+                    return passages_with_scores
             else:
                 return []
 
@@ -2750,9 +2753,11 @@ class AgentManager:
                             if query_tags.intersection(passage_tags):
                                 filtered_passages.append(passage)
 
-                return filtered_passages
+                # Return as tuples with empty metadata for SQL path
+                return [(p, 0.0, {}) for p in filtered_passages]
 
-            return pydantic_passages
+            # Return as tuples with empty metadata for SQL path
+            return [(p, 0.0, {}) for p in pydantic_passages]
 
     @enforce_types
     @trace_method
@@ -2766,7 +2771,7 @@ class AgentManager:
         top_k: Optional[int] = None,
         start_datetime: Optional[str] = None,
         end_datetime: Optional[str] = None,
-    ) -> Tuple[List[Dict[str, Any]], int]:
+    ) -> List[Dict[str, Any]]:
         """
         Search archival memory using semantic (embedding-based) search with optional temporal filtering.
 
@@ -2783,11 +2788,11 @@ class AgentManager:
             end_datetime: Filter results before this datetime (ISO 8601 format)
 
         Returns:
-            Tuple of (formatted_results, count)
+            List of formatted results with relevance metadata
         """
         # Handle empty or whitespace-only queries
         if not query or not query.strip():
-            return [], 0
+            return []
 
         # Get the agent to access timezone and embedding config
         agent_state = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor)
@@ -2839,7 +2844,7 @@ class AgentManager:
 
         # Get results using existing passage query method
         limit = top_k if top_k is not None else RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-        all_results = await self.query_agent_passages_async(
+        passages_with_metadata = await self.query_agent_passages_async(
             actor=actor,
             agent_id=agent_id,
             query_text=query,
@@ -2852,11 +2857,11 @@ class AgentManager:
             end_date=end_date,
         )
 
-        # Format results to include tags with friendly timestamps
+        # Format results to include tags with friendly timestamps and relevance metadata
         formatted_results = []
-        for result in all_results:
+        for passage, score, metadata in passages_with_metadata:
             # Format timestamp in agent's timezone if available
-            timestamp = result.created_at
+            timestamp = passage.created_at
             if timestamp and agent_state.timezone:
                 try:
                     # Convert to agent's timezone
@@ -2871,9 +2876,26 @@ class AgentManager:
                 # Use ISO format if no timezone is set
                 formatted_timestamp = str(timestamp) if timestamp else "Unknown"
 
-            formatted_results.append({"timestamp": formatted_timestamp, "content": result.text, "tags": result.tags or []})
+            result_dict = {"timestamp": formatted_timestamp, "content": passage.text, "tags": passage.tags or []}
+
+            # Add relevance metadata if available
+            if metadata:
+                relevance_info = {
+                    k: v
+                    for k, v in {
+                        "rrf_score": metadata.get("combined_score"),
+                        "vector_rank": metadata.get("vector_rank"),
+                        "fts_rank": metadata.get("fts_rank"),
+                    }.items()
+                    if v is not None
+                }
+
+                if relevance_info:  # Only add if we have metadata
+                    result_dict["relevance"] = relevance_info
+
+            formatted_results.append(result_dict)
 
-        return formatted_results, len(formatted_results)
+        return formatted_results
 
     @enforce_types
     @trace_method
@@ -3698,45 +3720,3 @@ class AgentManager:
             num_archival_memories=num_archival_memories,
             num_messages=num_messages,
         )
-
-    async def get_or_set_vector_db_namespace_async(
-        self,
-        agent_id: str,
-        organization_id: str,
-    ) -> str:
-        """Get the vector database namespace for an agent, creating it if it doesn't exist.
-
-        Args:
-            agent_id: Agent ID to check/store namespace
-            organization_id: Organization ID for namespace generation
-
-        Returns:
-            The org-scoped namespace name
-        """
-        from sqlalchemy import update
-
-        from letta.settings import settings
-
-        async with db_registry.async_session() as session:
-            # check if namespace already exists
-            result = await session.execute(select(AgentModel._vector_db_namespace).where(AgentModel.id == agent_id))
-            row = result.fetchone()
-
-            if row and row[0]:
-                return row[0]
-
-            # TODO: In the future, we might use agent_id for sharding the namespace
-            # For now, all messages in an org share the same namespace
-
-            # generate org-scoped namespace name
-            environment = settings.environment
-            if environment:
-                namespace_name = f"messages_{organization_id}_{environment.lower()}"
-            else:
-                namespace_name = f"messages_{organization_id}"
-
-            # update the agent with the namespace (keeps agent-level tracking for future sharding)
-            await session.execute(update(AgentModel).where(AgentModel.id == agent_id).values(_vector_db_namespace=namespace_name))
-            await session.commit()
-
-            return namespace_name

letta/services/agent_serialization_manager.py

@@ -12,6 +12,7 @@ from letta.errors import (
     AgentNotFoundForExportError,
 )
 from letta.helpers.pinecone_utils import should_use_pinecone
+from letta.helpers.tpuf_client import should_use_tpuf
 from letta.log import get_logger
 from letta.schemas.agent import AgentState, CreateAgent
 from letta.schemas.agent_file import (
@@ -29,7 +30,7 @@ from letta.schemas.agent_file import (
 )
 from letta.schemas.block import Block
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import FileProcessingStatus
+from letta.schemas.enums import FileProcessingStatus, VectorDBProvider
 from letta.schemas.file import FileMetadata
 from letta.schemas.group import Group, GroupCreate
 from letta.schemas.mcp import MCPServer
@@ -90,7 +91,6 @@ class AgentSerializationManager:
         self.file_agent_manager = file_agent_manager
         self.message_manager = message_manager
         self.file_parser = MistralFileParser() if settings.mistral_api_key else MarkitdownFileParser()
-        self.using_pinecone = should_use_pinecone()
 
         # ID mapping state for export
         self._db_to_file_ids: Dict[str, str] = {}
@@ -208,6 +208,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}
+
         if agent_schema.messages:
             for message in agent_schema.messages:
                 message_file_id = self._map_db_to_file_id(message.id, MessageSchema.__id_prefix__)
@@ -588,7 +592,12 @@ class AgentSerializationManager:
             if schema.files and any(f.content for f in schema.files):
                 # Use override embedding config if provided, otherwise use agent's config
                 embedder_config = override_embedding_config if override_embedding_config else schema.agents[0].embedding_config
-                if should_use_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=embedder_config)
+                elif should_use_pinecone():
                     embedder = PineconeEmbedder(embedding_config=embedder_config)
                 else:
                     embedder = OpenAIEmbedder(embedding_config=embedder_config)
@@ -596,7 +605,6 @@ class AgentSerializationManager:
                     file_parser=self.file_parser,
                     embedder=embedder,
                     actor=actor,
-                    using_pinecone=self.using_pinecone,
                 )
 
                 for file_schema in schema.files:
@@ -646,9 +654,10 @@ 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:
-                    for var in agent_data["tool_exec_environment_variables"]:
-                        var["value"] = env_vars.get(var["key"], "")
+                if env_vars and agent_data.get("tool_exec_environment_variables"):
+                    # update environment variable values from the provided env_vars dict
+                    for key in agent_data["tool_exec_environment_variables"]:
+                        agent_data["tool_exec_environment_variables"][key] = env_vars.get(key, "")
 
                 # Override project_id if provided
                 if project_id:
@@ -675,7 +684,12 @@ class AgentSerializationManager:
                     # Map file ID to the generated database ID immediately
                     message_file_to_db_ids[message_schema.id] = message_obj.id
 
-                created_messages = await self.message_manager.create_many_messages_async(pydantic_msgs=messages, actor=actor)
+                created_messages = await self.message_manager.create_many_messages_async(
+                    pydantic_msgs=messages,
+                    actor=actor,
+                    project_id=created_agent.project_id,
+                    template_id=created_agent.template_id,
+                )
                 imported_count += len(created_messages)
 
                 # Remap in_context_message_ids from file IDs to database IDs