letta-nightly 0.11.7.dev20250914103918__py3-none-any.whl → 0.11.7.dev20250916104104__py3-none-any.whl

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

@@ -1,4 +1,4 @@
-from typing import Annotated, List, Optional
+from typing import Annotated, List, Literal, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
 from fastapi.responses import JSONResponse
@@ -10,7 +10,7 @@ from letta.schemas.group import Group, GroupCreate, GroupUpdate, ManagerType
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
-from letta.server.rest_api.utils import get_letta_server
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.server import SyncServer
 
 router = APIRouter(prefix="/groups", tags=["groups"])
@@ -19,11 +19,19 @@ router = APIRouter(prefix="/groups", tags=["groups"])
 @router.get("/", response_model=List[Group], operation_id="list_groups")
 async def list_groups(
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     manager_type: Optional[ManagerType] = Query(None, description="Search groups by manager type"),
-    before: Optional[str] = Query(None, description="Cursor for pagination"),
-    after: Optional[str] = Query(None, description="Cursor for pagination"),
-    limit: Optional[int] = Query(None, description="Limit for pagination"),
+    before: Optional[str] = Query(
+        None, description="Group ID cursor for pagination. Returns groups that come before this group ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Group ID cursor for pagination. Returns groups that come after this group ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of groups to return"),
+    order: Literal["asc", "desc"] = Query(
+        "asc", description="Sort order for groups by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     project_id: Optional[str] = Query(None, description="Search groups by project id"),
     show_hidden_groups: bool | None = Query(
         False,
@@ -34,7 +42,7 @@ async def list_groups(
     """
     Fetch all multi-agent groups matching query.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     return await server.group_manager.list_groups_async(
         actor=actor,
         project_id=project_id,
@@ -42,6 +50,7 @@ async def list_groups(
         before=before,
         after=after,
         limit=limit,
+        ascending=(order == "asc"),
         show_hidden_groups=show_hidden_groups,
     )
 
@@ -49,12 +58,12 @@ async def list_groups(
 @router.get("/count", response_model=int, operation_id="count_groups")
 async def count_groups(
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get the count of all groups associated with a given user.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     return await server.group_manager.size(actor=actor)
 
 
@@ -62,12 +71,12 @@ async def count_groups(
 async def retrieve_group(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Retrieve the group by id.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
     try:
         return await server.group_manager.retrieve_group_async(group_id=group_id, actor=actor)
@@ -79,7 +88,7 @@ async def retrieve_group(
 async def create_group(
     group: GroupCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     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
@@ -88,7 +97,7 @@ async def create_group(
     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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.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))
@@ -99,7 +108,7 @@ async def modify_group(
     group_id: str,
     group: GroupUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     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
@@ -108,7 +117,7 @@ async def modify_group(
     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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.group_manager.modify_group_async(group_id=group_id, group_update=group, actor=actor)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
@@ -118,12 +127,12 @@ async def modify_group(
 async def delete_group(
     group_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Delete a multi-agent group.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     try:
         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"})
@@ -140,13 +149,13 @@ async def send_group_message(
     group_id: str,
     server: SyncServer = Depends(get_letta_server),
     request: LettaRequest = Body(...),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Process a user message and return the group's response.
     This endpoint accepts a message from a user and processes it through through agents in the group based on the specified pattern
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,
@@ -178,14 +187,14 @@ async def send_group_message_streaming(
     group_id: str,
     server: SyncServer = Depends(get_letta_server),
     request: LettaStreamingRequest = Body(...),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Process a user message and return the group's responses.
     This endpoint accepts a message from a user and processes it through agents in the group based on the specified pattern.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,
@@ -211,32 +220,42 @@ async def modify_group_message(
     message_id: str,
     request: LettaMessageUpdateUnion = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Update the details of a message associated with an agent.
     """
     # TODO: support modifying tool calls/returns
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.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")
 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."),
-    before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
-    limit: int = Query(10, description="Maximum number of messages to retrieve."),
+    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(10, description="Maximum number of messages to retrieve"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for messages by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     use_assistant_message: bool = Query(True, description="Whether to use assistant messages"),
     assistant_message_tool_name: str = Query(DEFAULT_MESSAGE_TOOL, description="The name of the designated message tool."),
     assistant_message_tool_kwarg: str = Query(DEFAULT_MESSAGE_TOOL_KWARG, description="The name of the message argument."),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Retrieve message history for an agent.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     group = await server.group_manager.retrieve_group_async(group_id=group_id, actor=actor)
     if group.manager_agent_id:
         return await server.get_agent_recall_async(
@@ -246,7 +265,7 @@ async def list_group_messages(
             before=before,
             limit=limit,
             group_id=group_id,
-            reverse=True,
+            reverse=(order == "desc"),
             return_message_object=False,
             use_assistant_message=use_assistant_message,
             assistant_message_tool_name=assistant_message_tool_name,
@@ -258,6 +277,7 @@ async def list_group_messages(
             after=after,
             before=before,
             limit=limit,
+            ascending=(order == "asc"),
             actor=actor,
             use_assistant_message=use_assistant_message,
             assistant_message_tool_name=assistant_message_tool_name,
@@ -269,10 +289,10 @@ async def list_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"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Delete the group messages for all agents that are part of the multi-agent group.
     """
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     await server.group_manager.reset_messages_async(group_id=group_id, actor=actor)

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

@@ -12,8 +12,8 @@ router = APIRouter(prefix="/health", tags=["health"])
 
 
 # Health check
-@router.get("/", response_model=Health, operation_id="health_check")
-def health_check():
+@router.get("/", response_model=Health, operation_id="check_health")
+def check_health():
     return Health(
         version=__version__,
         status="ok",

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

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Literal, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound, UniqueConstraintViolationError
+from letta.schemas.agent import AgentState
+from letta.schemas.block import Block
 from letta.schemas.identity import Identity, IdentityCreate, IdentityProperty, IdentityType, IdentityUpdate, IdentityUpsert
-from letta.server.rest_api.utils import get_letta_server
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -18,17 +20,27 @@ async def list_identities(
     project_id: Optional[str] = Query(None),
     identifier_key: Optional[str] = Query(None),
     identity_type: Optional[IdentityType] = Query(None),
-    before: Optional[str] = Query(None),
-    after: Optional[str] = Query(None),
-    limit: Optional[int] = Query(50),
+    before: Optional[str] = Query(
+        None,
+        description="Identity ID cursor for pagination. Returns identities that come before this identity ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Identity ID cursor for pagination. Returns identities that come after this identity ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of identities to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for identities by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get a list of all identities in the database
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
         identities = await server.identity_manager.list_identities_async(
             name=name,
@@ -38,6 +50,7 @@ async def list_identities(
             before=before,
             after=after,
             limit=limit,
+            ascending=(order == "asc"),
             actor=actor,
         )
     except HTTPException:
@@ -52,13 +65,13 @@ async def list_identities(
 @router.get("/count", tags=["identities"], response_model=int, operation_id="count_identities")
 async def count_identities(
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get count of all identities for a user
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.size_async(actor=actor)
     except NoResultFound:
         return 0
@@ -72,10 +85,10 @@ async def count_identities(
 async def retrieve_identity(
     identity_id: str,
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.get_identity_async(identity_id=identity_id, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -85,13 +98,13 @@ async def retrieve_identity(
 async def create_identity(
     identity: IdentityCreate = Body(...),
     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
+    headers: HeaderParams = Depends(get_headers),
     x_project: Optional[str] = Header(
         None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
     ),  # Only handled by next js middleware
 ):
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.create_identity_async(identity=identity, actor=actor)
     except HTTPException:
         raise
@@ -111,13 +124,13 @@ async def create_identity(
 async def upsert_identity(
     identity: IdentityUpsert = Body(...),
     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
+    headers: HeaderParams = Depends(get_headers),
     x_project: Optional[str] = Header(
         None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
     ),  # Only handled by next js middleware
 ):
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.upsert_identity_async(identity=identity, actor=actor)
     except HTTPException:
         raise
@@ -132,10 +145,10 @@ async def modify_identity(
     identity_id: str,
     identity: IdentityUpdate = Body(...),
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.update_identity_async(identity_id=identity_id, identity=identity, actor=actor)
     except HTTPException:
         raise
@@ -150,10 +163,10 @@ async def upsert_identity_properties(
     identity_id: str,
     properties: List[IdentityProperty] = Body(...),
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.upsert_identity_properties_async(identity_id=identity_id, properties=properties, actor=actor)
     except HTTPException:
         raise
@@ -167,13 +180,13 @@ async def upsert_identity_properties(
 async def delete_identity(
     identity_id: str,
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Delete an identity by its identifier key
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         await server.identity_manager.delete_identity_async(identity_id=identity_id, actor=actor)
     except HTTPException:
         raise
@@ -181,3 +194,79 @@ async def delete_identity(
         raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.get("/{identity_id}/agents", response_model=List[AgentState], operation_id="list_agents_for_identity")
+async def list_agents_for_identity(
+    identity_id: str,
+    before: Optional[str] = Query(
+        None,
+        description="Agent ID cursor for pagination. Returns agents that come before this agent ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Agent ID cursor for pagination. Returns agents that come after this agent ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of agents to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for agents by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get all agents associated with the specified identity.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.identity_manager.list_agents_for_identity_async(
+            identity_id=identity_id,
+            before=before,
+            after=after,
+            limit=limit,
+            ascending=(order == "asc"),
+            actor=actor,
+        )
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.get("/{identity_id}/blocks", response_model=List[Block], operation_id="list_blocks_for_identity")
+async def list_blocks_for_identity(
+    identity_id: str,
+    before: Optional[str] = Query(
+        None,
+        description="Block ID cursor for pagination. Returns blocks that come before this block ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Block ID cursor for pagination. Returns blocks that come after this block ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of blocks to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for blocks by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get all blocks associated with the specified identity.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.identity_manager.list_blocks_for_identity_async(
+            identity_id=identity_id,
+            before=before,
+            after=after,
+            limit=limit,
+            ascending=(order == "asc"),
+            actor=actor,
+        )
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")

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

@@ -1,12 +1,12 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
 from pydantic import BaseModel
 
 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.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.server import SyncServer
 
 router = APIRouter(prefix="/_internal_templates", tags=["_internal_templates"])
@@ -16,13 +16,13 @@ router = APIRouter(prefix="/_internal_templates", tags=["_internal_templates"])
 async def create_group(
     group: InternalTemplateGroupCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.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))
@@ -32,13 +32,13 @@ async def create_group(
 async def create_agent(
     agent: InternalTemplateAgentCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Create a new agent with template-related fields.
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.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))
@@ -48,13 +48,13 @@ async def create_agent(
 async def create_block(
     block: InternalTemplateBlockCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Create a new block with template-related fields.
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         block_obj = Block(**block.model_dump())
         return await server.block_manager.create_or_update_block_async(block_obj, actor=actor)
     except Exception as e:
@@ -68,6 +68,8 @@ class DeploymentEntity(BaseModel):
     type: str
     name: Optional[str] = None
     description: Optional[str] = None
+    entity_id: Optional[str] = None
+    project_id: Optional[str] = None
 
 
 class ListDeploymentEntitiesResponse(BaseModel):
@@ -92,7 +94,7 @@ class DeleteDeploymentResponse(BaseModel):
 async def list_deployment_entities(
     deployment_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     entity_types: Optional[List[str]] = Query(None, description="Filter by entity types (block, agent, group)"),
 ):
     """
@@ -100,7 +102,7 @@ async def list_deployment_entities(
     Optionally filter by entity types.
     """
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
         entities = []
 
@@ -140,6 +142,8 @@ async def list_deployment_entities(
                             type="block",
                             name=getattr(block, "template_name", None) or getattr(block, "label", None),
                             description=block.description,
+                            entity_id=getattr(block, "entity_id", None),
+                            project_id=getattr(block, "project_id", None),
                         )
                     )
 
@@ -155,7 +159,16 @@ async def list_deployment_entities(
                 agents = result.scalars().all()
 
                 for agent in agents:
-                    entities.append(DeploymentEntity(id=agent.id, type="agent", name=agent.name, description=agent.description))
+                    entities.append(
+                        DeploymentEntity(
+                            id=agent.id,
+                            type="agent",
+                            name=agent.name,
+                            description=agent.description,
+                            entity_id=getattr(agent, "entity_id", None),
+                            project_id=getattr(agent, "project_id", None),
+                        )
+                    )
 
         # Query groups if requested
         if "group" in types_to_include:
@@ -175,6 +188,8 @@ async def list_deployment_entities(
                             type="group",
                             name=None,  # Groups don't have a name field
                             description=group.description,
+                            entity_id=getattr(group, "entity_id", None),
+                            project_id=getattr(group, "project_id", None),
                         )
                     )
 
@@ -191,14 +206,14 @@ async def list_deployment_entities(
 async def delete_deployment(
     deployment_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
         deleted_blocks = []
         deleted_agents = []