langgraph-api 0.4.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

langgraph_api/api/assistants.py

@@ -1,6 +1,8 @@
+from functools import partial
 from typing import Any
 from uuid import uuid4
 
+import jsonschema_rs
 import structlog
 
 # TODO: Remove dependency on langchain-core here.
@@ -12,18 +14,28 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api import store as api_store
-from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
+from langgraph_api.encryption.middleware import (
+    decrypt_response,
+    decrypt_responses,
+    encrypt_request,
+)
+from langgraph_api.feature_flags import (
+    IS_POSTGRES_OR_GRPC_BACKEND,
+    USE_RUNTIME_CONTEXT_API,
+)
 from langgraph_api.graph import get_assistant_id, get_graph
+from langgraph_api.grpc.ops import Assistants as GrpcAssistants
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
-from langgraph_api.schema import ASSISTANT_FIELDS
-from langgraph_api.serde import ajson_loads
+from langgraph_api.schema import ASSISTANT_ENCRYPTION_FIELDS, ASSISTANT_FIELDS
+from langgraph_api.serde import json_loads
 from langgraph_api.utils import (
     fetchone,
     get_pagination_headers,
     validate_select_columns,
     validate_uuid,
 )
+from langgraph_api.utils.headers import get_configurable_headers
 from langgraph_api.validation import (
     AssistantCountRequest,
     AssistantCreate,
@@ -31,14 +43,22 @@ from langgraph_api.validation import (
     AssistantSearchRequest,
     AssistantVersionChange,
     AssistantVersionsSearchRequest,
+    ConfigValidator,
 )
 from langgraph_runtime.checkpoint import Checkpointer
-from langgraph_runtime.database import connect
-from langgraph_runtime.ops import Assistants
+from langgraph_runtime.database import connect as base_connect
 from langgraph_runtime.retry import retry_db
 
 logger = structlog.stdlib.get_logger(__name__)
 
+if IS_POSTGRES_OR_GRPC_BACKEND:
+    CrudAssistants = GrpcAssistants
+else:
+    from langgraph_runtime.ops import Assistants
+
+    CrudAssistants = Assistants
+
+connect = partial(base_connect, supports_core_api=IS_POSTGRES_OR_GRPC_BACKEND)
 
 EXCLUDED_CONFIG_SCHEMA = (
     "__pregel_checkpointer",
@@ -54,7 +74,7 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
 
     Important: we only return the `configurable` part of the schema.
 
-    The default get_config_schema method returns the entire schema (RunnableConfig),
+    The default get_config_schema method returns the entire schema (Config),
     which includes other root keys like "max_concurrency", which we
     do not want to expose.
 
@@ -110,21 +130,21 @@ def _graph_schemas(graph: Pregel) -> dict:
         input_schema = graph.get_input_jsonschema()
     except Exception as e:
         logger.warning(
-            f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
+            f"Failed to get input schema for graph {graph.name} with error: `{e!s}`"
         )
         input_schema = None
     try:
         output_schema = graph.get_output_jsonschema()
     except Exception as e:
         logger.warning(
-            f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
+            f"Failed to get output schema for graph {graph.name} with error: `{e!s}`"
         )
         output_schema = None
     try:
         state_schema = _state_jsonschema(graph)
     except Exception as e:
         logger.warning(
-            f"Failed to get state schema for graph {graph.name} with error: `{str(e)}`"
+            f"Failed to get state schema for graph {graph.name} with error: `{e!s}`"
         )
         state_schema = None
 
@@ -132,7 +152,7 @@ def _graph_schemas(graph: Pregel) -> dict:
         config_schema = _get_configurable_jsonschema(graph)
     except Exception as e:
         logger.warning(
-            f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
+            f"Failed to get config schema for graph {graph.name} with error: `{e!s}`"
         )
         config_schema = None
 
@@ -141,7 +161,7 @@ def _graph_schemas(graph: Pregel) -> dict:
             context_schema = graph.get_context_jsonschema()
         except Exception as e:
             logger.warning(
-                f"Failed to get context schema for graph {graph.name} with error: `{str(e)}`"
+                f"Failed to get context schema for graph {graph.name} with error: `{e!s}`"
             )
             context_schema = graph.config_schema()  # type: ignore[deprecated]
     else:
@@ -162,19 +182,40 @@ async def create_assistant(request: ApiRequest) -> ApiResponse:
     payload = await request.json(AssistantCreate)
     if assistant_id := payload.get("assistant_id"):
         validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    config = payload.get("config")
+    if config:
+        try:
+            ConfigValidator.validate(config)
+        except jsonschema_rs.ValidationError as e:
+            raise HTTPException(status_code=422, detail=str(e)) from e
+
+    encrypted_payload = await encrypt_request(
+        payload,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+
     async with connect() as conn:
-        assistant = await Assistants.put(
+        assistant = await CrudAssistants.put(
             conn,
             assistant_id or str(uuid4()),
-            config=payload.get("config") or {},
-            context=payload.get("context") or {},
+            config=encrypted_payload.get("config") or {},
+            context=encrypted_payload.get("context"),  # None if not provided
             graph_id=payload["graph_id"],
-            metadata=payload.get("metadata") or {},
+            metadata=encrypted_payload.get("metadata") or {},
             if_exists=payload.get("if_exists") or "raise",
             name=payload.get("name") or "Untitled",
             description=payload.get("description"),
         )
-    return ApiResponse(await fetchone(assistant, not_found_code=409))
+
+    # Decrypt metadata, config, and context in response
+    assistant_data = await fetchone(assistant, not_found_code=409)
+    assistant_data = await decrypt_response(
+        assistant_data,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(assistant_data)
 
 
 @retry_db
@@ -185,10 +226,17 @@ async def search_assistants(
     payload = await request.json(AssistantSearchRequest)
     select = validate_select_columns(payload.get("select") or None, ASSISTANT_FIELDS)
     offset = int(payload.get("offset") or 0)
+    config = payload.get("config")
+    if config:
+        try:
+            ConfigValidator.validate(config)
+        except jsonschema_rs.ValidationError as e:
+            raise HTTPException(status_code=422, detail=str(e)) from e
     async with connect() as conn:
-        assistants_iter, next_offset = await Assistants.search(
+        assistants_iter, next_offset = await CrudAssistants.search(
             conn,
             graph_id=payload.get("graph_id"),
+            name=payload.get("name"),
             metadata=payload.get("metadata"),
             limit=int(payload.get("limit") or 10),
             offset=offset,
@@ -199,7 +247,15 @@ async def search_assistants(
     assistants, response_headers = await get_pagination_headers(
         assistants_iter, next_offset, offset
     )
-    return ApiResponse(assistants, headers=response_headers)
+
+    # Decrypt metadata, config, and context in all returned assistants
+    decrypted_assistants = await decrypt_responses(
+        assistants,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+
+    return ApiResponse(decrypted_assistants, headers=response_headers)
 
 
 @retry_db
@@ -209,9 +265,10 @@ async def count_assistants(
     """Count assistants."""
     payload = await request.json(AssistantCountRequest)
     async with connect() as conn:
-        count = await Assistants.count(
+        count = await CrudAssistants.count(
             conn,
             graph_id=payload.get("graph_id"),
+            name=payload.get("name"),
             metadata=payload.get("metadata"),
         )
     return ApiResponse(count)
@@ -225,8 +282,16 @@ async def get_assistant(
     """Get an assistant by ID."""
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant = await Assistants.get(conn, assistant_id)
-    return ApiResponse(await fetchone(assistant))
+        assistant = await CrudAssistants.get(conn, assistant_id)
+
+    # Decrypt metadata, config, and context in response
+    assistant_data = await fetchone(assistant)
+    assistant_data = await decrypt_response(
+        assistant_data,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(assistant_data)
 
 
 @retry_db
@@ -237,14 +302,18 @@ async def get_assistant_graph(
     assistant_id = get_assistant_id(str(request.path_params["assistant_id"]))
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-    config = await ajson_loads(assistant["config"])
+    config = json_loads(assistant["config"])
+    configurable = config.setdefault("configurable", {})
+    configurable.update(get_configurable_headers(request.headers))
+
     async with get_graph(
         assistant["graph_id"],
         config,
         checkpointer=Checkpointer(),
         store=(await api_store.get_store()),
+        is_for_execution=False,
     ) as graph:
         xray: bool | int = False
         xray_query = request.query_params.get("xray")
@@ -291,41 +360,45 @@ async def get_assistant_subgraphs(
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = await ajson_loads(assistant["config"])
-        async with get_graph(
-            assistant["graph_id"],
-            config,
-            checkpointer=Checkpointer(),
-            store=(await api_store.get_store()),
-        ) as graph:
-            namespace = request.path_params.get("namespace")
-
-            if isinstance(graph, BaseRemotePregel):
-                return ApiResponse(
-                    await graph.fetch_subgraphs(
+
+    config = json_loads(assistant["config"])
+    configurable = config.setdefault("configurable", {})
+    configurable.update(get_configurable_headers(request.headers))
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_store()),
+        is_for_execution=False,
+    ) as graph:
+        namespace = request.path_params.get("namespace")
+
+        if isinstance(graph, BaseRemotePregel):
+            return ApiResponse(
+                await graph.fetch_subgraphs(
+                    namespace=namespace,
+                    recurse=request.query_params.get("recurse", "False")
+                    in ("true", "True"),
+                )
+            )
+
+        try:
+            return ApiResponse(
+                {
+                    ns: _graph_schemas(subgraph)
+                    async for ns, subgraph in graph.aget_subgraphs(
                         namespace=namespace,
                         recurse=request.query_params.get("recurse", "False")
                         in ("true", "True"),
                     )
-                )
-
-            try:
-                return ApiResponse(
-                    {
-                        ns: _graph_schemas(subgraph)
-                        async for ns, subgraph in graph.aget_subgraphs(
-                            namespace=namespace,
-                            recurse=request.query_params.get("recurse", "False")
-                            in ("true", "True"),
-                        )
-                    }
-                )
-            except NotImplementedError:
-                raise HTTPException(
-                    422, detail="The graph does not support visualization"
-                ) from None
+                }
+            )
+        except NotImplementedError:
+            raise HTTPException(
+                422, detail="The graph does not support visualization"
+            ) from None
 
 
 @retry_db
@@ -336,38 +409,41 @@ async def get_assistant_schemas(
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
-        # TODO Implementa  cache so we can de-dent and release this connection.
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = await ajson_loads(assistant["config"])
-        async with get_graph(
-            assistant["graph_id"],
-            config,
-            checkpointer=Checkpointer(),
-            store=(await api_store.get_store()),
-        ) as graph:
-            if isinstance(graph, BaseRemotePregel):
-                schemas = await graph.fetch_state_schema()
-                return ApiResponse(
-                    {
-                        "graph_id": assistant["graph_id"],
-                        "input_schema": schemas.get("input"),
-                        "output_schema": schemas.get("output"),
-                        "state_schema": schemas.get("state"),
-                        "config_schema": schemas.get("config"),
-                        "context_schema": schemas.get("context"),
-                    }
-                )
-
-            schemas = _graph_schemas(graph)
 
+    config = json_loads(assistant["config"])
+    configurable = config.setdefault("configurable", {})
+    configurable.update(get_configurable_headers(request.headers))
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_store()),
+        is_for_execution=False,
+    ) as graph:
+        if isinstance(graph, BaseRemotePregel):
+            schemas = await graph.fetch_state_schema()
             return ApiResponse(
                 {
                     "graph_id": assistant["graph_id"],
-                    **schemas,
+                    "input_schema": schemas.get("input"),
+                    "output_schema": schemas.get("output"),
+                    "state_schema": schemas.get("state"),
+                    "config_schema": schemas.get("config"),
+                    "context_schema": schemas.get("context"),
                 }
             )
 
+        schemas = _graph_schemas(graph)
+
+        return ApiResponse(
+            {
+                "graph_id": assistant["graph_id"],
+                **schemas,
+            }
+        )
+
 
 @retry_db
 async def patch_assistant(
@@ -377,27 +453,58 @@ async def patch_assistant(
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     payload = await request.json(AssistantPatch)
+    config = payload.get("config")
+    if config:
+        try:
+            ConfigValidator.validate(config)
+        except jsonschema_rs.ValidationError as e:
+            raise HTTPException(status_code=422, detail=str(e)) from e
+
+    encrypted_fields = await encrypt_request(
+        payload,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+
     async with connect() as conn:
-        assistant = await Assistants.patch(
+        assistant = await CrudAssistants.patch(
             conn,
             assistant_id,
-            config=payload.get("config"),
-            context=payload.get("context"),
+            config=encrypted_fields.get("config"),
+            context=encrypted_fields.get("context"),
             graph_id=payload.get("graph_id"),
-            metadata=payload.get("metadata"),
+            metadata=encrypted_fields.get("metadata"),
             name=payload.get("name"),
             description=payload.get("description"),
         )
-    return ApiResponse(await fetchone(assistant))
+
+    # Decrypt metadata, config, and context in response
+    assistant_data = await fetchone(assistant)
+    assistant_data = await decrypt_response(
+        assistant_data,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(assistant_data)
 
 
 @retry_db
 async def delete_assistant(request: ApiRequest) -> Response:
-    """Delete an assistant by ID."""
+    """Delete an assistant by ID.
+
+    Query params:
+        delete_threads: If "true", delete all threads where
+            metadata.assistant_id matches this assistant.
+    """
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
-    async with connect() as conn:
-        aid = await Assistants.delete(conn, assistant_id)
+    delete_threads = request.query_params.get("delete_threads", "").lower() == "true"
+
+    aid = await CrudAssistants.delete(
+        None,
+        assistant_id,
+        delete_threads=delete_threads,
+    )
     await fetchone(aid)
     return Response(status_code=204)
 
@@ -409,7 +516,7 @@ async def get_assistant_versions(request: ApiRequest) -> ApiResponse:
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     payload = await request.json(AssistantVersionsSearchRequest)
     async with connect() as conn:
-        assistants_iter = await Assistants.get_versions(
+        assistants_iter = await CrudAssistants.get_versions(
             conn,
             assistant_id,
             metadata=payload.get("metadata") or {},
@@ -421,7 +528,15 @@ async def get_assistant_versions(request: ApiRequest) -> ApiResponse:
         raise HTTPException(
             status_code=404, detail=f"Assistant {assistant_id} not found"
         )
-    return ApiResponse(assistants)
+
+    # Decrypt metadata, config, and context in all assistant versions
+    decrypted_assistants = await decrypt_responses(
+        assistants,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+
+    return ApiResponse(decrypted_assistants)
 
 
 @retry_db
@@ -431,10 +546,18 @@ async def set_latest_assistant_version(request: ApiRequest) -> ApiResponse:
     payload = await request.json(AssistantVersionChange)
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant = await Assistants.set_latest(
+        assistant = await CrudAssistants.set_latest(
             conn, assistant_id, payload.get("version")
         )
-    return ApiResponse(await fetchone(assistant, not_found_code=404))
+
+    # Decrypt metadata, config, and context in response
+    assistant_data = await fetchone(assistant, not_found_code=404)
+    assistant_data = await decrypt_response(
+        assistant_data,
+        "assistant",
+        ASSISTANT_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(assistant_data)
 
 
 assistants_routes: list[BaseRoute] = [

langgraph_api/api/mcp.py

@@ -193,13 +193,13 @@ async def handle_post_request(request: ApiRequest) -> Response:
     # Careful ID checks as the integer 0 is a valid ID
     if id_ is not None and method:
         # JSON-RPC request
-        return await handle_jsonrpc_request(request, cast(JsonRpcRequest, message))
+        return await handle_jsonrpc_request(request, cast("JsonRpcRequest", message))
     elif id_ is not None:
         # JSON-RPC response
-        return handle_jsonrpc_response(cast(JsonRpcResponse, message))
+        return handle_jsonrpc_response(cast("JsonRpcResponse", message))
     elif method:
         # JSON-RPC notification
-        return handle_jsonrpc_notification(cast(JsonRpcNotification, message))
+        return handle_jsonrpc_notification(cast("JsonRpcNotification", message))
     else:
         # Invalid message format
         return create_error_response(

langgraph_api/api/meta.py

@@ -1,9 +1,10 @@
-from typing import cast
-
 import langgraph.version
+import structlog
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from langgraph_api import __version__, config, metadata
+from langgraph_api.feature_flags import FF_USE_CORE_API
+from langgraph_api.grpc.ops import Runs as GrpcRuns
 from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
 from langgraph_api.route import ApiRequest
 from langgraph_license.validation import plus_features_enabled
@@ -11,8 +12,12 @@ from langgraph_runtime.database import connect, pool_stats
 from langgraph_runtime.metrics import get_metrics
 from langgraph_runtime.ops import Runs
 
+CrudRuns = GrpcRuns if FF_USE_CORE_API else Runs
+
 METRICS_FORMATS = {"prometheus", "json"}
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 async def meta_info(request: ApiRequest):
     plus = plus_features_enabled()
@@ -23,7 +28,8 @@ async def meta_info(request: ApiRequest):
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,
-                "langsmith": bool(config.LANGSMITH_API_KEY) and bool(config.TRACING),
+                "langsmith": bool(config.LANGSMITH_CONTROL_PLANE_API_KEY)
+                and bool(config.TRACING),
                 "langsmith_tracing_replicas": True,
             },
             "host": {
@@ -45,7 +51,7 @@ async def meta_metrics(request: ApiRequest):
 
     # collect stats
     metrics = get_metrics()
-    worker_metrics = cast(dict[str, int], metrics["workers"])
+    worker_metrics = metrics["workers"]
     workers_max = worker_metrics["max"]
     workers_active = worker_metrics["active"]
     workers_available = worker_metrics["available"]
@@ -64,42 +70,60 @@ async def meta_metrics(request: ApiRequest):
         async with connect() as conn:
             resp = {
                 **pg_redis_stats,
-                "queue": await Runs.stats(conn),
+                "queue": await CrudRuns.stats(conn),
                 **http_metrics,
             }
             if config.N_JOBS_PER_WORKER > 0:
                 resp["workers"] = worker_metrics
             return JSONResponse(resp)
     elif metrics_format == "prometheus":
-        async with connect() as conn:
-            queue_stats = await Runs.stats(conn)
+        metrics = []
+        try:
+            async with connect() as conn:
+                queue_stats = await CrudRuns.stats(conn)
 
-            metrics = [
-                "# HELP lg_api_num_pending_runs The number of runs currently pending.",
-                "# TYPE lg_api_num_pending_runs gauge",
-                f'lg_api_num_pending_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_pending"]}',
-                "# HELP lg_api_num_running_runs The number of runs currently running.",
-                "# TYPE lg_api_num_running_runs gauge",
-                f'lg_api_num_running_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_running"]}',
-            ]
-
-            if config.N_JOBS_PER_WORKER > 0:
                 metrics.extend(
                     [
-                        "# HELP lg_api_workers_max The maximum number of workers available.",
-                        "# TYPE lg_api_workers_max gauge",
-                        f'lg_api_workers_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_max}',
-                        "# HELP lg_api_workers_active The number of currently active workers.",
-                        "# TYPE lg_api_workers_active gauge",
-                        f'lg_api_workers_active{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_active}',
-                        "# HELP lg_api_workers_available The number of available (idle) workers.",
-                        "# TYPE lg_api_workers_available gauge",
-                        f'lg_api_workers_available{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_available}',
+                        "# HELP lg_api_num_pending_runs The number of runs currently pending.",
+                        "# TYPE lg_api_num_pending_runs gauge",
+                        f'lg_api_num_pending_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_pending"]}',
+                        "# HELP lg_api_num_running_runs The number of runs currently running.",
+                        "# TYPE lg_api_num_running_runs gauge",
+                        f'lg_api_num_running_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_running"]}',
+                        "# HELP lg_api_pending_runs_wait_time_max The maximum time a run has been pending, in seconds.",
+                        "# TYPE lg_api_pending_runs_wait_time_max gauge",
+                        f'lg_api_pending_runs_wait_time_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_max_secs") or 0}',
+                        "# HELP lg_api_pending_runs_wait_time_med The median pending wait time across runs, in seconds.",
+                        "# TYPE lg_api_pending_runs_wait_time_med gauge",
+                        f'lg_api_pending_runs_wait_time_med{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_med_secs") or 0}',
+                        "# HELP lg_api_pending_unblocked_runs_wait_time_max The maximum time a run has been pending excluding runs blocked by another run on the same thread, in seconds.",
+                        "# TYPE lg_api_pending_unblocked_runs_wait_time_max gauge",
+                        f'lg_api_pending_unblocked_runs_wait_time_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_unblocked_runs_wait_time_max_secs") or 0}',
                     ]
                 )
+        except Exception as e:
+            # if we get a db connection error/timeout, just skip queue stats
+            await logger.awarning(
+                "Ignoring error while getting run stats for /metrics", exc_info=e
+            )
+
+        if config.N_JOBS_PER_WORKER > 0:
+            metrics.extend(
+                [
+                    "# HELP lg_api_workers_max The maximum number of workers available.",
+                    "# TYPE lg_api_workers_max gauge",
+                    f'lg_api_workers_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_max}',
+                    "# HELP lg_api_workers_active The number of currently active workers.",
+                    "# TYPE lg_api_workers_active gauge",
+                    f'lg_api_workers_active{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_active}',
+                    "# HELP lg_api_workers_available The number of available (idle) workers.",
+                    "# TYPE lg_api_workers_available gauge",
+                    f'lg_api_workers_available{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_available}',
+                ]
+            )
 
-            metrics.extend(http_metrics)
-            metrics.extend(pg_redis_stats)
+        metrics.extend(http_metrics)
+        metrics.extend(pg_redis_stats)
 
         metrics_response = "\n".join(metrics)
         return PlainTextResponse(metrics_response)