letta-nightly 0.11.7.dev20250915104130__py3-none-any.whl → 0.11.7.dev20250917104122__py3-none-any.whl

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

@@ -1,26 +1,31 @@
 from typing import Optional
 
-from fastapi import APIRouter, Depends, Header
+from fastapi import APIRouter, Depends
 
 from letta.schemas.provider_trace import ProviderTrace
-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
 
 router = APIRouter(prefix="/telemetry", tags=["telemetry"])
 
 
-@router.get("/{step_id}", response_model=Optional[ProviderTrace], operation_id="retrieve_provider_trace")
-async def retrieve_provider_trace_by_step_id(
+@router.get("/{step_id}", response_model=Optional[ProviderTrace], operation_id="retrieve_provider_trace", deprecated=True)
+async def retrieve_provider_trace(
     step_id: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: str | None = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    headers: HeaderParams = Depends(get_headers),
 ):
+    """
+    **DEPRECATED**: Use `GET /steps/{step_id}/trace` instead.
+
+    Retrieve provider trace by step ID.
+    """
     provider_trace = None
     if settings.track_provider_trace:
         try:
             provider_trace = await server.telemetry_manager.get_provider_trace_by_step_id_async(
-                step_id=step_id, actor=await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+                step_id=step_id, actor=await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
             )
         except:
             pass

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

@@ -1,6 +1,6 @@
 import json
 from collections.abc import AsyncGenerator
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from composio.client import ComposioClientError, HTTPError, NoItemsFound
 from composio.client.collections import ActionModel, AppModel
@@ -11,7 +11,7 @@ from composio.exceptions import (
     EnumMetadataNotFound,
     EnumStringNotFound,
 )
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Request
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, Request
 from httpx import ConnectError, HTTPStatusError
 from pydantic import BaseModel, Field
 from starlette.responses import StreamingResponse
@@ -34,8 +34,8 @@ from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateSt
 from letta.schemas.message import Message
 from letta.schemas.pip_requirement import PipRequirement
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode
-from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.services.mcp.oauth_utils import MCPOAuthSession, drill_down_exception, oauth_stream_event
 from letta.services.mcp.stdio_client import AsyncStdioMCPClient
@@ -51,12 +51,12 @@ logger = get_logger(__name__)
 async def delete_tool(
     tool_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 a tool by name
     """
-    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.tool_manager.delete_tool_by_id_async(tool_id=tool_id, actor=actor)
 
 
@@ -75,7 +75,7 @@ async def count_tools(
     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"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get a count of all tools available to agents belonging to the org of the user.
@@ -110,7 +110,7 @@ async def count_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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
         # Combine single name with names list for unified processing (same logic as list_tools)
         combined_names = []
@@ -158,12 +158,12 @@ async def count_tools(
 async def retrieve_tool(
     tool_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),
 ):
     """
     Get a tool 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)
     tool = await server.tool_manager.get_tool_by_id_async(tool_id=tool_id, actor=actor)
     if tool is None:
         # return 404 error
@@ -173,9 +173,18 @@ async def retrieve_tool(
 
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
 async def list_tools(
-    after: Optional[str] = None,
-    limit: Optional[int] = 50,
-    name: Optional[str] = None,
+    before: Optional[str] = Query(
+        None, description="Tool ID cursor for pagination. Returns tools that come before this tool ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Tool ID cursor for pagination. Returns tools that come after this tool ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of tools to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for tools 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 by single tool name"),
     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"
@@ -187,10 +196,10 @@ async def list_tools(
     ),
     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
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
-    Get a list of all tools available to agents belonging to the org of the user
+    Get a list of all tools available to agents.
     """
     try:
         # Helper function to parse tool types - supports both repeated params and comma-separated values
@@ -222,7 +231,7 @@ async def 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)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
         # Combine single name with names list for unified processing
         combined_names = []
@@ -254,8 +263,10 @@ async def list_tools(
         # Get the list of tools using unified query
         return await server.tool_manager.list_tools_async(
             actor=actor,
+            before=before,
             after=after,
             limit=limit,
+            ascending=(order == "asc"),
             tool_types=tool_types_str,
             exclude_tool_types=exclude_tool_types_str,
             names=final_names,
@@ -271,13 +282,13 @@ async def list_tools(
 async def create_tool(
     request: ToolCreate = 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),
 ):
     """
     Create a new tool
     """
     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)
         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:
@@ -295,13 +306,13 @@ async def create_tool(
 async def upsert_tool(
     request: ToolCreate = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Create or update a tool
     """
     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)
         tool = await server.tool_manager.create_or_update_tool_async(
             pydantic_tool=Tool(**request.model_dump(exclude_unset=True)), actor=actor
         )
@@ -322,13 +333,13 @@ async def modify_tool(
     tool_id: str,
     request: ToolUpdate = 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),
 ):
     """
     Update an existing tool
     """
     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)
         tool = await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
         return tool
     except LettaToolNameConflictError as e:
@@ -345,12 +356,12 @@ async def modify_tool(
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
 async def upsert_base_tools(
     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),
 ):
     """
     Upsert base tools
     """
-    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.tool_manager.upsert_base_tools_async(actor=actor)
 
 
@@ -358,12 +369,12 @@ async def upsert_base_tools(
 async def run_tool_from_source(
     server: SyncServer = Depends(get_letta_server),
     request: ToolRunFromSource = 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),
 ):
     """
     Attempt to build a tool from source, then run it on the provided arguments
     """
-    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.run_tool_from_source(
@@ -388,11 +399,14 @@ async def run_tool_from_source(
 
 # Specific routes for Composio
 @router.get("/composio/apps", response_model=List[AppModel], operation_id="list_composio_apps")
-def list_composio_apps(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
+def list_composio_apps(
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
     """
     Get a list of all Composio apps
     """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
     composio_api_key = get_composio_api_key(actor=actor, logger=logger)
     if not composio_api_key:
         raise HTTPException(
@@ -406,12 +420,12 @@ def list_composio_apps(server: SyncServer = Depends(get_letta_server), user_id:
 def list_composio_actions_by_app(
     composio_app_name: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get a list of all Composio actions for a specific app
     """
-    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)
     composio_api_key = get_composio_api_key(actor=actor, logger=logger)
     if not composio_api_key:
         raise HTTPException(
@@ -425,12 +439,12 @@ def list_composio_actions_by_app(
 async def add_composio_tool(
     composio_action_name: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
     """
-    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:
         tool_create = ToolCreate.from_composio(action_name=composio_action_name)
@@ -515,14 +529,17 @@ async def add_composio_tool(
     response_model=dict[str, Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]],
     operation_id="list_mcp_servers",
 )
-async def list_mcp_servers(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
+async def list_mcp_servers(
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
     """
     Get a list of all configured MCP servers
     """
     if tool_settings.mcp_read_from_config:
         return server.get_mcp_servers()
     else:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=user_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         mcp_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
         return {server.server_name: server.to_config(resolve_variables=False) for server in mcp_servers}
 
@@ -533,13 +550,13 @@ async def list_mcp_servers(server: SyncServer = Depends(get_letta_server), user_
 async def list_mcp_tools_by_server(
     mcp_server_name: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Get a list of all tools for a specific MCP server
     """
     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)
         mcp_tools = await server.mcp_manager.list_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor)
         return mcp_tools
     except Exception as e:
@@ -576,7 +593,7 @@ async def list_mcp_tools_by_server(
 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"),
+    headers: HeaderParams = Depends(get_headers),
     agent_id: Optional[str] = None,
 ):
     """
@@ -588,7 +605,7 @@ async def resync_mcp_server_tools(
 
     Returns a summary of changes made.
     """
-    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:
         result = await server.mcp_manager.resync_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor, agent_id=agent_id)
@@ -619,12 +636,12 @@ async def add_mcp_tool(
     mcp_server_name: str,
     mcp_tool_name: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Register a new MCP tool as a Letta server by MCP server + tool name
     """
-    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)
 
     if tool_settings.mcp_read_from_config:
         try:
@@ -698,48 +715,29 @@ async def add_mcp_tool(
 async def add_mcp_server_to_config(
     request: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig] = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Add a new MCP server to the Letta MCP server config
     """
     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)
 
         if tool_settings.mcp_read_from_config:
             # write to config file
             return await server.add_mcp_server_to_config(server_config=request, allow_upsert=True)
         else:
             # log to DB
-            from letta.schemas.mcp import MCPServer
-
-            if isinstance(request, StdioServerConfig):
-                mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
-                # don't allow stdio servers
-                if tool_settings.mcp_disable_stdio:  # protected server
-                    raise HTTPException(
-                        status_code=400,
-                        detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
-                    )
-            elif isinstance(request, SSEServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
-                )
-            elif isinstance(request, StreamableHTTPServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
+            # Check if stdio servers are disabled
+            if isinstance(request, StdioServerConfig) and tool_settings.mcp_disable_stdio:
+                raise HTTPException(
+                    status_code=400,
+                    detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
                 )
 
             # Create MCP server and optimistically sync tools
-            await server.mcp_manager.create_mcp_server_with_tools(mapped_request, actor=actor)
+            # The mcp_manager will handle encryption of sensitive fields
+            await server.mcp_manager.create_mcp_server_from_config_with_tools(request, actor=actor)
 
             # TODO: don't do this in the future (just return MCPServer)
             all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
@@ -767,13 +765,13 @@ async def update_mcp_server(
     mcp_server_name: str,
     request: Union[UpdateStdioMCPServer, UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer] = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Update an existing MCP server 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)
 
         if tool_settings.mcp_read_from_config:
             raise HTTPException(status_code=501, detail="Update not implemented for config file mode, config files to be deprecated.")
@@ -797,7 +795,7 @@ async def update_mcp_server(
 async def delete_mcp_server_from_config(
     mcp_server_name: str,
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Delete a MCP server configuration
@@ -807,7 +805,7 @@ async def delete_mcp_server_from_config(
         return server.delete_mcp_server_from_config(server_name=mcp_server_name)
     else:
         # log to DB
-        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)
         mcp_server_id = await server.mcp_manager.get_mcp_server_id_by_name(mcp_server_name, actor)
         await server.mcp_manager.delete_mcp_server_by_id(mcp_server_id, actor=actor)
 
@@ -821,7 +819,7 @@ async def delete_mcp_server_from_config(
 async def test_mcp_server(
     request: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig] = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Test connection to an MCP server without adding it.
@@ -829,7 +827,7 @@ async def test_mcp_server(
     """
     client = None
     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)
         request.resolve_environment_variables()
         client = await server.mcp_manager.get_mcp_client(request, actor)
 
@@ -888,7 +886,7 @@ async def test_mcp_server(
 async def connect_mcp_server(
     request: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig] = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
     http_request: Request = None,
 ) -> StreamingResponse:
     """
@@ -907,7 +905,7 @@ async def connect_mcp_server(
             # Acknolwedge connection attempt
             yield oauth_stream_event(OauthStreamEvent.CONNECTION_ATTEMPT, server_name=request.server_name)
 
-            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)
 
             # Create MCP client with respective transport type
             try:
@@ -974,7 +972,7 @@ class CodeInput(BaseModel):
 async def generate_json_schema(
     request: CodeInput = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Generate a JSON schema from the given source code defining a function or class.
@@ -1005,7 +1003,7 @@ async def execute_mcp_tool(
     tool_name: str,
     request: MCPToolExecuteRequest = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Execute a specific MCP tool from a configured server.
@@ -1013,7 +1011,7 @@ async def execute_mcp_tool(
     """
     client = None
     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)
 
         # Get the MCP server by name
         mcp_server = await server.mcp_manager.get_mcp_server(mcp_server_name, actor)
@@ -1117,7 +1115,7 @@ class GenerateToolOutput(BaseModel):
 async def generate_tool_from_prompt(
     request: GenerateToolInput = Body(...),
     server: SyncServer = Depends(get_letta_server),
-    actor_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
     """
     Generate a tool from the given user prompt.
@@ -1125,7 +1123,7 @@ async def generate_tool_from_prompt(
     response_data = None
 
     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)
         llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or "anthropic/claude-3-5-sonnet-20240620")
         formatted_prompt = (
             f"Generate a python function named {request.tool_name} using the instructions below "

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

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, List, Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
 from letta.schemas.user import User, UserCreate, UserUpdate
-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.schemas.user import User

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

@@ -1,12 +1,13 @@
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict
 
 import openai
-from fastapi import APIRouter, Body, Depends, Header
+from fastapi import APIRouter, Body, Depends
 from fastapi.responses import StreamingResponse
 
 from letta.agents.voice_agent import VoiceAgent
 from letta.log import get_logger
-from letta.server.rest_api.utils import get_letta_server, get_user_message_from_chat_completions_request
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.server.rest_api.utils import get_user_message_from_chat_completions_request
 from letta.settings import model_settings
 
 if TYPE_CHECKING:
@@ -33,9 +34,9 @@ async def create_voice_chat_completions(
     agent_id: str,
     completion_request: Dict[str, Any] = Body(...),  # The validation is soft in case providers like VAPI send extra params
     server: "SyncServer" = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),
+    headers: HeaderParams = Depends(get_headers),
 ):
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=user_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
     # Create OpenAI async client
     client = openai.AsyncClient(

letta/server/rest_api/utils.py

@@ -3,7 +3,7 @@ import json
 import os
 import uuid
 from enum import Enum
-from typing import TYPE_CHECKING, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
+from typing import AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
 
 from fastapi import Header, HTTPException
 from openai.types.chat import ChatCompletionMessageParam
@@ -35,9 +35,6 @@ from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.system import get_heartbeat, package_function_response
 
-if TYPE_CHECKING:
-    from letta.server.server import SyncServer
-
 SENTRY_ENABLED = bool(os.getenv("SENTRY_DSN"))
 
 if SENTRY_ENABLED:
@@ -145,20 +142,6 @@ async def sse_async_generator(
             yield sse_formatter(SSE_FINISH_MSG)
 
 
-# TODO: why does this double up the interface?
-def get_letta_server() -> "SyncServer":
-    # Check if a global server is already instantiated
-    from letta.server.rest_api.app import server
-
-    # assert isinstance(server, SyncServer)
-    return server
-
-
-# Dependency to get user_id from headers
-def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optional[str]:
-    return user_id
-
-
 def capture_sentry_exception(e: BaseException):
     """This will capture the exception in sentry, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response"""
     if SENTRY_ENABLED: