letta-nightly 0.7.20.dev20250520104253__py3-none-any.whl → 0.7.21.dev20250521233415__py3-none-any.whl

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

@@ -33,6 +33,7 @@ from letta.schemas.user import User
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.services.telemetry_manager import NoopTelemetryManager
 from letta.settings import settings
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
@@ -106,14 +107,15 @@ async def list_agents(
 
 
 @router.get("/count", response_model=int, operation_id="count_agents")
-def count_agents(
+async def count_agents(
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Get the count of all agents associated with a given user.
     """
-    return server.agent_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.agent_manager.size_async(actor=actor)
 
 
 class IndentedORJSONResponse(Response):
@@ -124,7 +126,7 @@ class IndentedORJSONResponse(Response):
 
 
 @router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
-def export_agent_serialized(
+async def export_agent_serialized(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -135,7 +137,7 @@ def export_agent_serialized(
     """
     Export the serialized JSON representation of an agent, formatted with indentation.
     """
-    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:
         agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor)
@@ -200,7 +202,7 @@ async def import_agent_serialized(
 
 
 @router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="retrieve_agent_context_window")
-def retrieve_agent_context_window(
+async def retrieve_agent_context_window(
     agent_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
@@ -208,9 +210,12 @@ def retrieve_agent_context_window(
     """
     Retrieve the context window of a specific agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-
-    return server.get_agent_context_window(agent_id=agent_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    try:
+        return await server.get_agent_context_window_async(agent_id=agent_id, actor=actor)
+    except Exception as e:
+        traceback.print_exc()
+        raise e
 
 
 class CreateAgentRequest(CreateAgent):
@@ -341,7 +346,7 @@ async def retrieve_agent(
     """
     Get the state of the agent.
     """
-    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:
         return await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
@@ -367,7 +372,7 @@ def delete_agent(
 
 
 @router.get("/{agent_id}/sources", response_model=List[Source], operation_id="list_agent_sources")
-def list_agent_sources(
+async def list_agent_sources(
     agent_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
@@ -375,8 +380,8 @@ def list_agent_sources(
     """
     Get the sources associated with an agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.agent_manager.list_attached_sources(agent_id=agent_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.agent_manager.list_attached_sources_async(agent_id=agent_id, actor=actor)
 
 
 # TODO: remove? can also get with agent blocks
@@ -424,14 +429,14 @@ async def list_blocks(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     try:
-        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
+        agent = await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, include_relationships=["memory"], actor=actor)
         return agent.memory.blocks
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 
 
 @router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_core_memory_block")
-def modify_block(
+async def modify_block(
     agent_id: str,
     block_label: str,
     block_update: BlockUpdate = Body(...),
@@ -441,10 +446,11 @@ def modify_block(
     """
     Updates a core memory block of an agent.
     """
-    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)
 
-    block = server.agent_manager.get_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
-    block = server.block_manager.update_block(block.id, block_update=block_update, actor=actor)
+    block = await server.agent_manager.modify_block_by_label_async(
+        agent_id=agent_id, block_label=block_label, block_update=block_update, actor=actor
+    )
 
     # This should also trigger a system prompt change in the agent
     server.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True, update_timestamp=False)
@@ -481,7 +487,7 @@ def detach_block(
 
 
 @router.get("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="list_passages")
-def list_passages(
+async def list_passages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[str] = Query(None, description="Unique ID of the memory to start the query range at."),
@@ -496,11 +502,11 @@ def list_passages(
     """
     Retrieve the memories in an agent's archival memory store (paginated query).
     """
-    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 server.get_agent_archival(
-        user_id=actor.id,
+    return await server.get_agent_archival_async(
         agent_id=agent_id,
+        actor=actor,
         after=after,
         before=before,
         query_text=search,
@@ -564,7 +570,7 @@ AgentMessagesResponse = Annotated[
 
 
 @router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_messages")
-def list_messages(
+async def list_messages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[str] = Query(None, description="Message after which to retrieve the returned messages."),
@@ -579,10 +585,9 @@ def list_messages(
     """
     Retrieve message history for an agent.
     """
-    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 server.get_agent_recall(
-        user_id=actor.id,
+    return await server.get_agent_recall_async(
         agent_id=agent_id,
         after=after,
         before=before,
@@ -593,6 +598,7 @@ def list_messages(
         use_assistant_message=use_assistant_message,
         assistant_message_tool_name=assistant_message_tool_name,
         assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        actor=actor,
     )
 
 
@@ -634,7 +640,7 @@ async def send_message(
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "google_vertex", "google_ai"]
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
 
     if agent_eligible and feature_enabled and model_compatible:
         experimental_agent = LettaAgent(
@@ -644,6 +650,8 @@ async def send_message(
             block_manager=server.block_manager,
             passage_manager=server.passage_manager,
             actor=actor,
+            step_manager=server.step_manager,
+            telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
         )
 
         result = await experimental_agent.step(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message)
@@ -692,7 +700,8 @@ async def send_message_streaming(
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
     experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
     feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
+    model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
 
     if agent_eligible and feature_enabled and model_compatible and request.stream_tokens:
         experimental_agent = LettaAgent(
@@ -702,14 +711,28 @@ async def send_message_streaming(
             block_manager=server.block_manager,
             passage_manager=server.passage_manager,
             actor=actor,
+            step_manager=server.step_manager,
+            telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
         )
-
-        result = StreamingResponse(
-            experimental_agent.step_stream(
-                request.messages, max_steps=10, use_assistant_message=request.use_assistant_message, stream_tokens=request.stream_tokens
-            ),
-            media_type="text/event-stream",
-        )
+        from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode
+
+        if request.stream_tokens and model_compatible_token_streaming:
+            result = StreamingResponseWithStatusCode(
+                experimental_agent.step_stream(
+                    input_messages=request.messages,
+                    max_steps=10,
+                    use_assistant_message=request.use_assistant_message,
+                    request_start_timestamp_ns=request_start_timestamp_ns,
+                ),
+                media_type="text/event-stream",
+            )
+        else:
+            result = StreamingResponseWithStatusCode(
+                experimental_agent.step_stream_no_tokens(
+                    request.messages, max_steps=10, use_assistant_message=request.use_assistant_message
+                ),
+                media_type="text/event-stream",
+            )
     else:
         result = await server.send_message_to_agent(
             agent_id=agent_id,

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

@@ -99,7 +99,7 @@ def retrieve_block(
 
 
 @router.get("/{block_id}/agents", response_model=List[AgentState], operation_id="list_agents_for_block")
-def list_agents_for_block(
+async def list_agents_for_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -108,9 +108,9 @@ def list_agents_for_block(
     Retrieves all agents associated with the specified block.
     Raises a 404 if the block does not exist.
     """
-    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:
-        agents = server.block_manager.get_agents_for_block(block_id=block_id, actor=actor)
+        agents = await server.block_manager.get_agents_for_block_async(block_id=block_id, actor=actor)
         return agents
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Block with id={block_id} not found")

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

@@ -13,7 +13,7 @@ router = APIRouter(prefix="/identities", tags=["identities"])
 
 
 @router.get("/", tags=["identities"], response_model=List[Identity], operation_id="list_identities")
-def list_identities(
+async def list_identities(
     name: Optional[str] = Query(None),
     project_id: Optional[str] = Query(None),
     identifier_key: Optional[str] = Query(None),
@@ -28,9 +28,9 @@ def list_identities(
     Get a list of all identities in the database
     """
     try:
-        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)
 
-        identities = server.identity_manager.list_identities(
+        identities = await server.identity_manager.list_identities_async(
             name=name,
             project_id=project_id,
             identifier_key=identifier_key,
@@ -50,7 +50,7 @@ def list_identities(
 
 
 @router.get("/count", tags=["identities"], response_model=int, operation_id="count_identities")
-def count_identities(
+async def count_identities(
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -58,7 +58,8 @@ def count_identities(
     Get count of all identities for a user
     """
     try:
-        return server.identity_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.identity_manager.size_async(actor=actor)
     except NoResultFound:
         return 0
     except HTTPException:
@@ -68,28 +69,28 @@ def count_identities(
 
 
 @router.get("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="retrieve_identity")
-def retrieve_identity(
+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
 ):
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.identity_manager.get_identity(identity_id=identity_id, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=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))
 
 
 @router.post("/", tags=["identities"], response_model=Identity, operation_id="create_identity")
-def create_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
     x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
 ):
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.identity_manager.create_identity(identity=identity, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.identity_manager.create_identity_async(identity=identity, actor=actor)
     except HTTPException:
         raise
     except UniqueConstraintViolationError:
@@ -105,15 +106,15 @@ def create_identity(
 
 
 @router.put("/", tags=["identities"], response_model=Identity, operation_id="upsert_identity")
-def upsert_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
     x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
 ):
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.identity_manager.upsert_identity(identity=identity, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.identity_manager.upsert_identity_async(identity=identity, actor=actor)
     except HTTPException:
         raise
     except NoResultFound as e:
@@ -123,36 +124,33 @@ def upsert_identity(
 
 
 @router.patch("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="update_identity")
-def modify_identity(
+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
 ):
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.identity_manager.update_identity(identity_id=identity_id, identity=identity, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.identity_manager.update_identity_async(identity_id=identity_id, identity=identity, actor=actor)
     except HTTPException:
         raise
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
-        import traceback
-
-        print(traceback.format_exc())
         raise HTTPException(status_code=500, detail=f"{e}")
 
 
 @router.put("/{identity_id}/properties", tags=["identities"], operation_id="upsert_identity_properties")
-def upsert_identity_properties(
+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
 ):
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.identity_manager.upsert_identity_properties(identity_id=identity_id, properties=properties, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.identity_manager.upsert_identity_properties_async(identity_id=identity_id, properties=properties, actor=actor)
     except HTTPException:
         raise
     except NoResultFound as e:
@@ -162,7 +160,7 @@ def upsert_identity_properties(
 
 
 @router.delete("/{identity_id}", tags=["identities"], operation_id="delete_identity")
-def delete_identity(
+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
@@ -171,8 +169,8 @@ def delete_identity(
     Delete an identity by its identifier key
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        server.identity_manager.delete_identity(identity_id=identity_id, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        await server.identity_manager.delete_identity_async(identity_id=identity_id, actor=actor)
     except HTTPException:
         raise
     except NoResultFound as e:

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

@@ -33,16 +33,16 @@ def list_jobs(
 
 
 @router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
-def 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
 ):
     """
     List all active jobs.
     """
-    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 server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
+    return await server.job_manager.list_jobs_async(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
 
 @router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")

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

@@ -14,30 +14,35 @@ router = APIRouter(prefix="/models", tags=["models", "llms"])
 
 
 @router.get("/", response_model=List[LLMConfig], operation_id="list_models")
-def list_llm_models(
+async def list_llm_models(
     provider_category: Optional[List[ProviderCategory]] = Query(None),
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    # Extract user_id from header, default to None if not present
 ):
+    """List available LLM models using the asynchronous implementation for improved performance"""
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    models = server.list_llm_models(
+
+    models = await server.list_llm_models_async(
         provider_category=provider_category,
         provider_name=provider_name,
         provider_type=provider_type,
         actor=actor,
     )
-    # print(models)
+
     return models
 
 
 @router.get("/embedding", response_model=List[EmbeddingConfig], operation_id="list_embedding_models")
-def 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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    # Extract user_id from header, default to None if not present
 ):
+    """List available embedding models using the asynchronous implementation for improved performance"""
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    models = server.list_embedding_models(actor=actor)
-    # print(models)
+    models = await server.list_embedding_models_async(actor=actor)
+
     return models

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

@@ -100,15 +100,15 @@ def delete_sandbox_config(
 
 
 @router.get("/", response_model=List[PydanticSandboxConfig])
-def list_sandbox_configs(
+async def list_sandbox_configs(
     limit: int = Query(1000, description="Number of results to return"),
     after: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     sandbox_type: Optional[SandboxType] = Query(None, description="Filter for this specific sandbox type"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.sandbox_config_manager.list_sandbox_configs(actor, limit=limit, after=after, sandbox_type=sandbox_type)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.list_sandbox_configs_async(actor, limit=limit, after=after, sandbox_type=sandbox_type)
 
 
 @router.post("/local/recreate-venv", response_model=PydanticSandboxConfig)
@@ -190,12 +190,12 @@ def delete_sandbox_env_var(
 
 
 @router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])
-def list_sandbox_env_vars(
+async def list_sandbox_env_vars(
     sandbox_config_id: str,
     limit: int = Query(1000, description="Number of results to return"),
     after: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: str = Depends(get_user_id),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.sandbox_config_manager.list_sandbox_env_vars(sandbox_config_id, actor, limit=limit, after=after)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.sandbox_config_manager.list_sandbox_env_vars_async(sandbox_config_id, actor, limit=limit, after=after)

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

@@ -12,7 +12,7 @@ router = APIRouter(prefix="/tags", tags=["tag", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[str], operation_id="list_tags")
-def list_tags(
+async def list_tags(
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -22,6 +22,6 @@ def list_tags(
     """
     Get a list of all tags in the database
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    tags = server.agent_manager.list_tags(actor=actor, after=after, limit=limit, query_text=query_text)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    tags = await server.agent_manager.list_tags_async(actor=actor, after=after, limit=limit, query_text=query_text)
     return tags

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

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, Depends, Header
+
+from letta.schemas.provider_trace import ProviderTrace
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/telemetry", tags=["telemetry"])
+
+
+@router.get("/{step_id}", response_model=ProviderTrace, operation_id="retrieve_provider_trace")
+async def retrieve_provider_trace_by_step_id(
+    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
+):
+    return 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)
+    )

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

@@ -59,7 +59,7 @@ def count_tools(
 
 
 @router.get("/{tool_id}", response_model=Tool, operation_id="retrieve_tool")
-def retrieve_tool(
+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
@@ -67,8 +67,8 @@ def retrieve_tool(
     """
     Get a tool by ID
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    tool = server.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=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
         raise HTTPException(status_code=404, detail=f"Tool with id {tool_id} not found.")
@@ -196,15 +196,15 @@ def modify_tool(
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
-def upsert_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
 ):
     """
     Upsert base tools
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.tool_manager.upsert_base_tools(actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.tool_manager.upsert_base_tools_async(actor=actor)
 
 
 @router.post("/run", response_model=ToolReturnMessage, operation_id="run_tool_from_source")