letta-nightly 0.11.6.dev20250902104140__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

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

@@ -351,7 +351,7 @@ async def list_folder_passages(
     List all passages associated with a data folder.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    return await server.agent_manager.list_passages_async(
+    return await server.agent_manager.query_source_passages_async(
         actor=actor,
         source_id=folder_id,
         after=after,

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

@@ -17,7 +17,7 @@ router = APIRouter(prefix="/groups", tags=["groups"])
 
 
 @router.get("/", response_model=List[Group], operation_id="list_groups")
-def list_groups(
+async def list_groups(
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
     manager_type: Optional[ManagerType] = Query(None, description="Search groups by manager type"),
@@ -29,8 +29,8 @@ def list_groups(
     """
     Fetch all multi-agent groups matching query.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.group_manager.list_groups(
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.group_manager.list_groups_async(
         actor=actor,
         project_id=project_id,
         manager_type=manager_type,
@@ -41,14 +41,15 @@ def list_groups(
 
 
 @router.get("/count", response_model=int, operation_id="count_groups")
-def count_groups(
+async def count_groups(
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Get the count of all groups associated with a given user.
     """
-    return server.group_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.group_manager.size(actor=actor)
 
 
 @router.get("/{group_id}", response_model=Group, operation_id="retrieve_group")
@@ -69,7 +70,7 @@ async def retrieve_group(
 
 
 @router.post("/", response_model=Group, operation_id="create_group")
-def create_group(
+async def create_group(
     group: GroupCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -81,8 +82,8 @@ def create_group(
     Create a new multi-agent group with the specified configuration.
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.group_manager.create_group(group, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.group_manager.create_group_async(group, actor=actor)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -108,7 +109,7 @@ async def modify_group(
 
 
 @router.delete("/{group_id}", response_model=None, operation_id="delete_group")
-def delete_group(
+async def delete_group(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -116,9 +117,9 @@ def delete_group(
     """
     Delete a multi-agent group.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     try:
-        server.group_manager.delete_group(group_id=group_id, actor=actor)
+        await server.group_manager.delete_group_async(group_id=group_id, actor=actor)
         return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Group id={group_id} successfully deleted"})
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Group id={group_id} not found for user_id={actor.id}.")
@@ -199,7 +200,7 @@ GroupMessagesResponse = Annotated[
 
 
 @router.patch("/{group_id}/messages/{message_id}", response_model=LettaMessageUnion, operation_id="modify_group_message")
-def modify_group_message(
+async def modify_group_message(
     group_id: str,
     message_id: str,
     request: LettaMessageUpdateUnion = Body(...),
@@ -210,12 +211,12 @@ def modify_group_message(
     Update the details of a message associated with an agent.
     """
     # TODO: support modifying tool calls/returns
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.message_manager.update_message_by_letta_message(message_id=message_id, letta_message_update=request, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.message_manager.update_message_by_letta_message(message_id=message_id, letta_message_update=request, actor=actor)
 
 
 @router.get("/{group_id}/messages", response_model=GroupMessagesResponse, operation_id="list_group_messages")
-def list_group_messages(
+async def list_group_messages(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[str] = Query(None, description="Message after which to retrieve the returned messages."),
@@ -229,10 +230,10 @@ def list_group_messages(
     """
     Retrieve message history for an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    group = server.group_manager.retrieve_group(group_id=group_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    group = await server.group_manager.retrieve_group_async(group_id=group_id, actor=actor)
     if group.manager_agent_id:
-        return server.get_agent_recall(
+        return await server.get_agent_recall_async(
             user_id=actor.id,
             agent_id=group.manager_agent_id,
             after=after,
@@ -246,7 +247,7 @@ def list_group_messages(
             assistant_message_tool_kwarg=assistant_message_tool_kwarg,
         )
     else:
-        return server.group_manager.list_group_messages(
+        return await server.group_manager.list_group_messages_async(
             group_id=group_id,
             after=after,
             before=before,
@@ -259,7 +260,7 @@ def list_group_messages(
 
 
 @router.patch("/{group_id}/reset-messages", response_model=None, operation_id="reset_group_messages")
-def reset_group_messages(
+async def reset_group_messages(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -267,5 +268,5 @@ def reset_group_messages(
     """
     Delete the group messages for all agents that are part of the multi-agent group.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    server.group_manager.reset_messages(group_id=group_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    await server.group_manager.reset_messages_async(group_id=group_id, actor=actor)

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

@@ -0,0 +1,68 @@
+from typing import Optional
+
+from fastapi import APIRouter, Body, Depends, Header, HTTPException
+
+from letta.schemas.agent import AgentState, InternalTemplateAgentCreate
+from letta.schemas.block import Block, InternalTemplateBlockCreate
+from letta.schemas.group import Group, InternalTemplateGroupCreate
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/_internal_templates", tags=["_internal_templates"])
+
+
+@router.post("/groups", response_model=Group, operation_id="create_internal_template_group")
+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.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.group_manager.create_group_async(group, actor=actor)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/agents", response_model=AgentState, operation_id="create_internal_template_agent")
+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.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.agent_manager.create_agent_async(agent, actor=actor)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/blocks", response_model=Block, operation_id="create_internal_template_block")
+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)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

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

@@ -6,11 +6,17 @@ from fastapi import APIRouter, Depends, HTTPException, Query
 
 from letta.log import get_logger
 from letta.schemas.enums import SandboxType
-from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticEnvVar
-from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate
-from letta.schemas.sandbox_config import LocalSandboxConfig
-from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
+from letta.schemas.environment_variables import (
+    SandboxEnvironmentVariable as PydanticEnvVar,
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+)
+from letta.schemas.sandbox_config import (
+    LocalSandboxConfig,
+    SandboxConfig as PydanticSandboxConfig,
+    SandboxConfigCreate,
+    SandboxConfigUpdate,
+)
 from letta.server.rest_api.utils import get_letta_server, get_user_id
 from letta.server.server import SyncServer
 from letta.services.helpers.tool_execution_helper import create_venv_for_local_sandbox, install_pip_requirements_for_sandbox

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

@@ -349,7 +349,7 @@ async def list_source_passages(
     List all passages associated with a data source.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    return await server.agent_manager.list_passages_async(
+    return await server.agent_manager.query_source_passages_async(
         actor=actor,
         source_id=source_id,
         after=after,

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

@@ -27,7 +27,7 @@ from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.orm.mcp_oauth import OAuthSessionStatus
 from letta.prompts.gpt_system import get_system_text
-from letta.schemas.enums import MessageRole
+from letta.schemas.enums import MessageRole, ToolType
 from letta.schemas.letta_message import ToolReturnMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer
@@ -62,16 +62,94 @@ async def delete_tool(
 
 @router.get("/count", response_model=int, operation_id="count_tools")
 async def count_tools(
+    name: Optional[str] = None,
+    names: Optional[List[str]] = Query(None, description="Filter by specific tool names"),
+    tool_ids: Optional[List[str]] = Query(
+        None, description="Filter by specific tool IDs - accepts repeated params or comma-separated values"
+    ),
+    search: Optional[str] = Query(None, description="Search tool names (case-insensitive partial match)"),
+    tool_types: Optional[List[str]] = Query(None, description="Filter by tool type(s) - accepts repeated params or comma-separated values"),
+    exclude_tool_types: Optional[List[str]] = Query(
+        None, description="Tool type(s) to exclude - accepts repeated params or comma-separated values"
+    ),
+    return_only_letta_tools: Optional[bool] = Query(False, description="Count only tools with tool_type starting with 'letta_'"),
+    exclude_letta_tools: Optional[bool] = Query(False, description="Exclude built-in Letta tools from the count"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-    include_base_tools: Optional[bool] = Query(False, description="Include built-in Letta tools in the count"),
 ):
     """
     Get a count of all tools available to agents belonging to the org of the user.
     """
     try:
+        # Helper function to parse tool types - supports both repeated params and comma-separated values
+        def parse_tool_types(tool_types_input: Optional[List[str]]) -> Optional[List[str]]:
+            if tool_types_input is None:
+                return None
+
+            # Flatten any comma-separated values and validate against ToolType enum
+            flattened_types = []
+            for item in tool_types_input:
+                # Split by comma in case user provided comma-separated values
+                types_in_item = [t.strip() for t in item.split(",") if t.strip()]
+                flattened_types.extend(types_in_item)
+
+            # Validate each type against the ToolType enum
+            valid_types = []
+            valid_values = [tt.value for tt in ToolType]
+
+            for tool_type in flattened_types:
+                if tool_type not in valid_values:
+                    raise HTTPException(
+                        status_code=400, detail=f"Invalid tool_type '{tool_type}'. Must be one of: {', '.join(valid_values)}"
+                    )
+                valid_types.append(tool_type)
+
+            return valid_types if valid_types else None
+
+        # Parse and validate tool types (same logic as list_tools)
+        tool_types_str = parse_tool_types(tool_types)
+        exclude_tool_types_str = parse_tool_types(exclude_tool_types)
+
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        return await server.tool_manager.size_async(actor=actor, include_base_tools=include_base_tools)
+
+        # Combine single name with names list for unified processing (same logic as list_tools)
+        combined_names = []
+        if name is not None:
+            combined_names.append(name)
+        if names is not None:
+            combined_names.extend(names)
+
+        # Use None if no names specified, otherwise use the combined list
+        final_names = combined_names if combined_names else None
+
+        # Helper function to parse tool IDs - supports both repeated params and comma-separated values
+        def parse_tool_ids(tool_ids_input: Optional[List[str]]) -> Optional[List[str]]:
+            if tool_ids_input is None:
+                return None
+
+            # Flatten any comma-separated values
+            flattened_ids = []
+            for item in tool_ids_input:
+                # Split by comma in case user provided comma-separated values
+                ids_in_item = [id.strip() for id in item.split(",") if id.strip()]
+                flattened_ids.extend(ids_in_item)
+
+            return flattened_ids if flattened_ids else None
+
+        # Parse tool IDs (same logic as list_tools)
+        final_tool_ids = parse_tool_ids(tool_ids)
+
+        # Get the count of tools using unified query
+        return await server.tool_manager.count_tools_async(
+            actor=actor,
+            tool_types=tool_types_str,
+            exclude_tool_types=exclude_tool_types_str,
+            names=final_names,
+            tool_ids=final_tool_ids,
+            search=search,
+            return_only_letta_tools=return_only_letta_tools,
+            exclude_letta_tools=exclude_letta_tools,
+        )
     except Exception as e:
         print(f"Error occurred: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -99,6 +177,16 @@ async def list_tools(
     after: Optional[str] = None,
     limit: Optional[int] = 50,
     name: Optional[str] = None,
+    names: Optional[List[str]] = Query(None, description="Filter by specific tool names"),
+    tool_ids: Optional[List[str]] = Query(
+        None, description="Filter by specific tool IDs - accepts repeated params or comma-separated values"
+    ),
+    search: Optional[str] = Query(None, description="Search tool names (case-insensitive partial match)"),
+    tool_types: Optional[List[str]] = Query(None, description="Filter by tool type(s) - accepts repeated params or comma-separated values"),
+    exclude_tool_types: Optional[List[str]] = Query(
+        None, description="Tool type(s) to exclude - accepts repeated params or comma-separated values"
+    ),
+    return_only_letta_tools: Optional[bool] = Query(False, description="Return only tools with tool_type starting with 'letta_'"),
     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
 ):
@@ -106,13 +194,76 @@ async def list_tools(
     Get a list of all tools available to agents belonging to the org of the user
     """
     try:
+        # Helper function to parse tool types - supports both repeated params and comma-separated values
+        def parse_tool_types(tool_types_input: Optional[List[str]]) -> Optional[List[str]]:
+            if tool_types_input is None:
+                return None
+
+            # Flatten any comma-separated values and validate against ToolType enum
+            flattened_types = []
+            for item in tool_types_input:
+                # Split by comma in case user provided comma-separated values
+                types_in_item = [t.strip() for t in item.split(",") if t.strip()]
+                flattened_types.extend(types_in_item)
+
+            # Validate each type against the ToolType enum
+            valid_types = []
+            valid_values = [tt.value for tt in ToolType]
+
+            for tool_type in flattened_types:
+                if tool_type not in valid_values:
+                    raise HTTPException(
+                        status_code=400, detail=f"Invalid tool_type '{tool_type}'. Must be one of: {', '.join(valid_values)}"
+                    )
+                valid_types.append(tool_type)
+
+            return valid_types if valid_types else None
+
+        # Parse and validate tool types
+        tool_types_str = parse_tool_types(tool_types)
+        exclude_tool_types_str = parse_tool_types(exclude_tool_types)
+
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+
+        # Combine single name with names list for unified processing
+        combined_names = []
         if name is not None:
-            tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)
-            return [tool] if tool else []
+            combined_names.append(name)
+        if names is not None:
+            combined_names.extend(names)
+
+        # Use None if no names specified, otherwise use the combined list
+        final_names = combined_names if combined_names else None
+
+        # Helper function to parse tool IDs - supports both repeated params and comma-separated values
+        def parse_tool_ids(tool_ids_input: Optional[List[str]]) -> Optional[List[str]]:
+            if tool_ids_input is None:
+                return None
 
-        # Get the list of tools
-        return await server.tool_manager.list_tools_async(actor=actor, after=after, limit=limit)
+            # Flatten any comma-separated values
+            flattened_ids = []
+            for item in tool_ids_input:
+                # Split by comma in case user provided comma-separated values
+                ids_in_item = [id.strip() for id in item.split(",") if id.strip()]
+                flattened_ids.extend(ids_in_item)
+
+            return flattened_ids if flattened_ids else None
+
+        # Parse tool IDs
+        final_tool_ids = parse_tool_ids(tool_ids)
+
+        # Get the list of tools using unified query
+        return await server.tool_manager.list_tools_async(
+            actor=actor,
+            after=after,
+            limit=limit,
+            tool_types=tool_types_str,
+            exclude_tool_types=exclude_tool_types_str,
+            names=final_names,
+            tool_ids=final_tool_ids,
+            search=search,
+            return_only_letta_tools=return_only_letta_tools,
+        )
     except Exception as e:
         # Log or print the full exception here for debugging
         print(f"Error occurred: {e}")
@@ -130,7 +281,7 @@ async def create_tool(
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        tool = Tool(**request.model_dump())
+        tool = Tool(**request.model_dump(exclude_unset=True))
         return await server.tool_manager.create_tool_async(pydantic_tool=tool, actor=actor)
     except UniqueConstraintViolationError as e:
         # Log or print the full exception here for debugging
@@ -162,7 +313,9 @@ async def upsert_tool(
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        tool = await server.tool_manager.create_or_update_tool_async(pydantic_tool=Tool(**request.model_dump()), actor=actor)
+        tool = await server.tool_manager.create_or_update_tool_async(
+            pydantic_tool=Tool(**request.model_dump(exclude_unset=True)), actor=actor
+        )
         return tool
     except UniqueConstraintViolationError as e:
         # Log the error and raise a conflict exception
@@ -190,18 +343,17 @@ async def modify_tool(
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        return await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
+        tool = await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
+        print("FINAL TOOL", tool)
+        return tool
     except LettaToolNameConflictError as e:
         # HTTP 409 == Conflict
-        print(f"Tool name conflict during update: {e}")
         raise HTTPException(status_code=409, detail=str(e))
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool update: {e}")
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -748,8 +900,8 @@ async def connect_mcp_server(
             except ConnectionError:
                 # TODO: jnjpng make this connection error check more specific to the 401 unauthorized error
                 if isinstance(client, AsyncStdioMCPClient):
-                    logger.warning(f"OAuth not supported for stdio")
-                    yield oauth_stream_event(OauthStreamEvent.ERROR, message=f"OAuth not supported for stdio")
+                    logger.warning("OAuth not supported for stdio")
+                    yield oauth_stream_event(OauthStreamEvent.ERROR, message="OAuth not supported for stdio")
                     return
                 # Continue to OAuth flow
                 logger.info(f"Attempting OAuth flow for {request}...")

letta/server/rest_api/streaming_response.py

@@ -185,7 +185,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
             try:
                 await asyncio.shield(self._protected_stream_response(send))
             except asyncio.CancelledError:
-                logger.info(f"Stream response was cancelled, but shielded task should continue")
+                logger.info("Stream response was cancelled, but shielded task should continue")
             except anyio.ClosedResourceError:
                 logger.info("Client disconnected, but shielded task should continue")
                 self._client_connected = False
@@ -296,9 +296,10 @@ class StreamingResponseWithStatusCode(StreamingResponse):
             raise LettaUnexpectedStreamCancellationError("Stream was terminated due to unexpected cancellation from server")
 
         except Exception as exc:
-            logger.exception("Unhandled Streaming Error")
+            logger.exception(f"Unhandled Streaming Error: {str(exc)}")
             more_body = False
-            error_resp = {"error": {"message": "Internal Server Error"}}
+            # error_resp = {"error": {"message": str(exc)}}
+            error_resp = {"error": str(exc), "code": "INTERNAL_SERVER_ERROR"}
             error_event = f"event: error\ndata: {json.dumps(error_resp)}\n\n".encode(self.charset)
             logger.debug("response_started:", self.response_started)
             if not self.response_started: