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

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

@@ -1,11 +1,11 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job
-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
 from letta.settings import settings
 
@@ -20,13 +20,13 @@ async def list_jobs(
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(50, description="Limit for pagination"),
     ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
-    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),
 ):
     """
     List all jobs.
     TODO (cliandy): implementation for pagination
     """
-    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)
 
     # TODO: add filtering by status
     return await server.job_manager.list_jobs_async(
@@ -42,7 +42,7 @@ async def list_jobs(
 @router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
 async def list_active_jobs(
     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),
     source_id: Optional[str] = Query(None, description="Only list jobs associated with the source."),
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
@@ -52,7 +52,7 @@ async def list_active_jobs(
     """
     List all active jobs.
     """
-    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.job_manager.list_jobs_async(
         actor=actor,
         statuses=[JobStatus.created, JobStatus.running],
@@ -67,13 +67,13 @@ async def list_active_jobs(
 @router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
 async def retrieve_job(
     job_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Get the status of a job.
     """
-    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.job_manager.get_job_by_id_async(job_id=job_id, actor=actor)
@@ -84,7 +84,7 @@ async def retrieve_job(
 @router.patch("/{job_id}/cancel", response_model=Job, operation_id="cancel_job")
 async def cancel_job(
     job_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
@@ -93,7 +93,7 @@ async def cancel_job(
     This endpoint marks a job as cancelled, which will cause any associated
     agent execution to terminate as soon as possible.
     """
-    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)
     if not settings.track_agent_run:
         raise HTTPException(status_code=400, detail="Agent run tracking is disabled")
 
@@ -113,13 +113,13 @@ async def cancel_job(
 @router.delete("/{job_id}", response_model=Job, operation_id="delete_job")
 async def delete_job(
     job_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Delete a job by its job_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:
         job = await server.job_manager.delete_job_by_id_async(job_id=job_id, actor=actor)

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

@@ -1,11 +1,11 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Depends, Header, Query
+from fastapi import APIRouter, Depends, Query
 
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.llm_config import LLMConfig
-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
@@ -19,11 +19,10 @@ async def list_llm_models(
     provider_name: Optional[str] = Query(None),
     provider_type: Optional[ProviderType] = Query(None),
     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),
 ):
     """List available LLM models using the asynchronous implementation for improved performance"""
-    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)
 
     models = await server.list_llm_models_async(
         provider_category=provider_category,
@@ -38,11 +37,10 @@ async def list_llm_models(
 @router.get("/embedding", response_model=List[EmbeddingConfig], operation_id="list_embedding_models")
 async def list_embedding_models(
     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),
 ):
     """List available embedding models using the asynchronous implementation for improved performance"""
-    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)
     models = await server.list_embedding_models_async(actor=actor)
 
     return models

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

@@ -1,6 +1,6 @@
 from typing import List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, Query
+from fastapi import APIRouter, Body, Depends, Query
 from fastapi.exceptions import HTTPException
 from starlette.requests import Request
 
@@ -10,7 +10,7 @@ from letta.orm.errors import NoResultFound
 from letta.schemas.job import BatchJob, JobStatus, JobType, JobUpdate
 from letta.schemas.letta_request import CreateBatch
 from letta.schemas.letta_response import LettaBatchMessages
-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
 from letta.settings import settings
 
@@ -19,23 +19,22 @@ router = APIRouter(prefix="/messages", tags=["messages"])
 logger = get_logger(__name__)
 
 
-# Batch APIs
-
-
 @router.post(
     "/batches",
     response_model=BatchJob,
-    operation_id="create_batch_run",
+    operation_id="create_batch",
 )
-async def create_batch_run(
+async def create_batch(
     request: Request,
     payload: CreateBatch = Body(..., description="Messages and config for all agents"),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
-    Submit a batch of agent messages for asynchronous processing.
+    Submit a batch of agent runs for asynchronous processing.
+
     Creates a job that will fan out messages to all listed agents and process them in parallel.
+    The request will be rejected if it exceeds 256MB.
     """
     # Reject requests greater than 256Mbs
     max_bytes = 256 * 1024 * 1024
@@ -48,7 +47,7 @@ async def create_batch_run(
     if not settings.enable_batch_job_polling:
         logger.warning("Batch job polling is disabled. Enable batch processing by setting LETTA_ENABLE_BATCH_JOB_POLLING 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)
     batch_job = BatchJob(
         user_id=actor.id,
         status=JobStatus.running,
@@ -76,10 +75,7 @@ async def create_batch_run(
 
         # TODO: update run metadata
     except Exception as e:
-        import traceback
-
-        print("Error creating batch job", e)
-        traceback.print_exc()
+        logger.error(f"Error creating batch job: {e}")
 
         # mark job as failed
         await server.job_manager.update_job_by_id_async(job_id=batch_job.id, job_update=JobUpdate(status=JobStatus.failed), actor=actor)
@@ -87,16 +83,16 @@ async def create_batch_run(
     return batch_job
 
 
-@router.get("/batches/{batch_id}", response_model=BatchJob, operation_id="retrieve_batch_run")
-async def retrieve_batch_run(
+@router.get("/batches/{batch_id}", response_model=BatchJob, operation_id="retrieve_batch")
+async def retrieve_batch(
     batch_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Get the status of a batch run.
+    Retrieve the status and details of a batch run.
     """
-    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:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
@@ -105,27 +101,45 @@ async def retrieve_batch_run(
         raise HTTPException(status_code=404, detail="Batch not found")
 
 
-@router.get("/batches", response_model=List[BatchJob], operation_id="list_batch_runs")
-async def list_batch_runs(
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+@router.get("/batches", response_model=List[BatchJob], operation_id="list_batches")
+async def list_batches(
+    before: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come before this job ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come after this job ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(100, description="Maximum number of jobs to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for jobs by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     List all batch runs.
     """
-    # TODO: filter
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-
-    jobs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.BATCH)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+
+    jobs = server.job_manager.list_jobs(
+        actor=actor,
+        statuses=[JobStatus.created, JobStatus.running],
+        job_type=JobType.BATCH,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+    )
     return [BatchJob.from_job(job) for job in jobs]
 
 
 @router.get(
     "/batches/{batch_id}/messages",
     response_model=LettaBatchMessages,
-    operation_id="list_batch_messages",
+    operation_id="list_messages_for_batch",
 )
-async def list_batch_messages(
+async def list_messages_for_batch(
     batch_id: str,
     before: Optional[str] = Query(
         None, description="Message ID cursor for pagination. Returns messages that come before this message ID in the specified sort order"
@@ -137,14 +151,17 @@ async def list_batch_messages(
     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"),
     agent_id: Optional[str] = Query(None, description="Filter messages by agent ID"),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: SyncServer = Depends(get_letta_server),
 ):
-    """Get response messages for a specific batch job."""
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    """
+    Get response messages for a specific batch job.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
-    # First, verify the batch job exists and the user has access to it
+    # Verify the batch job exists and the user has access to it
     try:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
         BatchJob.from_job(job)
@@ -159,16 +176,16 @@ async def list_batch_messages(
     return LettaBatchMessages(messages=messages)
 
 
-@router.patch("/batches/{batch_id}/cancel", operation_id="cancel_batch_run")
-async def cancel_batch_run(
+@router.patch("/batches/{batch_id}/cancel", operation_id="cancel_batch")
+async def cancel_batch(
     batch_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Cancel a batch run.
     """
-    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:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)

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

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, List, Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
 from letta.schemas.organization import Organization, OrganizationCreate, OrganizationUpdate
-from letta.server.rest_api.utils import get_letta_server
+from letta.server.rest_api.dependencies import get_letta_server
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer

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

@@ -1,13 +1,13 @@
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 from fastapi.responses import JSONResponse
 
 from letta.errors import LLMAuthenticationError
 from letta.orm.errors import NoResultFound
 from letta.schemas.enums import ProviderType
 from letta.schemas.providers import Provider, ProviderCheck, ProviderCreate, ProviderUpdate
-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
@@ -17,20 +17,31 @@ router = APIRouter(prefix="/providers", tags=["providers"])
 
 @router.get("/", response_model=List[Provider], operation_id="list_providers")
 async def list_providers(
-    name: Optional[str] = Query(None),
-    provider_type: Optional[ProviderType] = Query(None),
-    after: Optional[str] = Query(None),
-    limit: Optional[int] = Query(50),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    before: Optional[str] = Query(
+        None,
+        description="Provider ID cursor for pagination. Returns providers that come before this provider ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Provider ID cursor for pagination. Returns providers that come after this provider ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of providers to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for providers by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    name: Optional[str] = Query(None, description="Filter providers by name"),
+    provider_type: Optional[ProviderType] = Query(None, description="Filter providers by type"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Get a list of all custom providers in the database
+    Get a list of all custom providers.
     """
     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)
         providers = await server.provider_manager.list_providers_async(
-            after=after, limit=limit, actor=actor, name=name, provider_type=provider_type
+            before=before, after=after, limit=limit, actor=actor, name=name, provider_type=provider_type, ascending=(order == "asc")
         )
     except HTTPException:
         raise
@@ -39,16 +50,29 @@ async def list_providers(
     return providers
 
 
+@router.get("/{provider_id}", response_model=Provider, operation_id="retrieve_provider")
+async def retrieve_provider(
+    provider_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get a provider by ID.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.provider_manager.get_provider_async(provider_id=provider_id, actor=actor)
+
+
 @router.post("/", response_model=Provider, operation_id="create_provider")
 async def create_provider(
     request: ProviderCreate = Body(...),
-    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),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Create a new custom provider
+    Create a new custom provider.
     """
-    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)
     for field_name in request.model_fields:
         value = getattr(request, field_name, None)
         if isinstance(value, str) and value == "":
@@ -64,13 +88,13 @@ async def create_provider(
 async def modify_provider(
     provider_id: str,
     request: ProviderUpdate = Body(...),
-    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),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Update an existing custom provider
+    Update an existing custom provider.
     """
-    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.provider_manager.update_provider_async(provider_id=provider_id, provider_update=request, actor=actor)
 
 
@@ -79,6 +103,9 @@ async def check_provider(
     request: ProviderCheck = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
+    """
+    Verify the API key and additional parameters for a provider.
+    """
     try:
         if request.base_url and len(request.base_url) == 0:
             # set to null if empty string
@@ -96,14 +123,14 @@ async def check_provider(
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
 async def delete_provider(
     provider_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Delete an existing custom provider
+    Delete an existing custom provider.
     """
     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.provider_manager.delete_provider_by_id_async(provider_id=provider_id, actor=actor)
         return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Provider id={provider_id} successfully deleted"})
     except NoResultFound:

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

@@ -1,25 +1,25 @@
 from datetime import timedelta
 from typing import Annotated, List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
 from pydantic import Field
 
 from letta.data_sources.redis_client import NoopAsyncRedisClient, get_redis_client
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.orm.errors import NoResultFound
-from letta.schemas.enums import JobStatus, JobType, MessageRole
+from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import RetrieveStreamRequest
 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.dependencies import HeaderParams, get_headers, get_letta_server
 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,
     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
 
@@ -38,12 +38,12 @@ def list_runs(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default)",
     ),
-    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),
 ):
     """
     List all runs.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
 
     runs = [
         Run.from_job(job)
@@ -68,12 +68,12 @@ def list_active_runs(
     server: "SyncServer" = Depends(get_letta_server),
     agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),
     background: Optional[bool] = Query(None, description="If True, filters for runs that were created in background mode."),
-    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),
 ):
     """
     List all active runs.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
 
     active_runs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.RUN)
     active_runs = [Run.from_job(job) for job in active_runs]
@@ -90,13 +90,13 @@ def list_active_runs(
 @router.get("/{run_id}", response_model=Run, operation_id="retrieve_run")
 def retrieve_run(
     run_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Get the status of a run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
 
     try:
         job = server.job_manager.get_job_by_id(job_id=run_id, actor=actor)
@@ -118,7 +118,7 @@ RunMessagesResponse = Annotated[
 async def list_run_messages(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     before: Optional[str] = Query(
         None, description="Message ID cursor for pagination. Returns messages that come before this message ID in the specified sort order"
     ),
@@ -131,7 +131,7 @@ async def list_run_messages(
     ),
 ):
     """Get response messages associated with a run."""
-    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:
         messages = server.job_manager.get_run_messages(
@@ -150,13 +150,13 @@ async def list_run_messages(
 @router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="retrieve_run_usage")
 def retrieve_run_usage(
     run_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Get usage statistics for a run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
 
     try:
         usage = server.job_manager.get_job_usage(job_id=run_id, actor=actor)
@@ -173,7 +173,7 @@ def retrieve_run_usage(
 async def list_run_steps(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
@@ -197,7 +197,7 @@ async def list_run_steps(
     if order not in ["asc", "desc"]:
         raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
 
-    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:
         steps = server.job_manager.get_job_steps(
@@ -216,13 +216,13 @@ async def list_run_steps(
 @router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
 async def delete_run(
     run_id: str,
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Delete a run by its run_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:
         job = await server.job_manager.delete_job_by_id_async(job_id=run_id, actor=actor)
@@ -266,10 +266,10 @@ async def delete_run(
 async def retrieve_stream(
     run_id: str,
     request: RetrieveStreamRequest = Body(None),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     server: "SyncServer" = Depends(get_letta_server),
 ):
-    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:
         job = server.job_manager.get_job_by_id(job_id=run_id, actor=actor)
     except NoResultFound: