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

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.5.4"
+__version__ = "0.7.3"

langgraph_api/api/__init__.py

@@ -6,41 +6,81 @@ import os
 
 import structlog
 from starlette.applications import Starlette
+from starlette.exceptions import HTTPException
+from starlette.middleware import Middleware
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, JSONResponse, Response
 from starlette.routing import BaseRoute, Route
 
+from langgraph_api import timing
 from langgraph_api.api.a2a import a2a_routes
 from langgraph_api.api.assistants import assistants_routes
 from langgraph_api.api.mcp import mcp_routes
 from langgraph_api.api.meta import meta_info, meta_metrics
 from langgraph_api.api.openapi import get_openapi_spec
+from langgraph_api.api.profile import profile_routes
 from langgraph_api.api.runs import runs_routes
 from langgraph_api.api.store import store_routes
 from langgraph_api.api.threads import threads_routes
 from langgraph_api.api.ui import ui_routes
 from langgraph_api.auth.middleware import auth_middleware
-from langgraph_api.config import HTTP_CONFIG, MIGRATIONS_PATH, MOUNT_PREFIX
+from langgraph_api.config import (
+    FF_PYSPY_PROFILING_ENABLED,
+    HTTP_CONFIG,
+    LANGGRAPH_ENCRYPTION,
+    MIGRATIONS_PATH,
+    MOUNT_PREFIX,
+)
+from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
 from langgraph_api.graph import js_bg_tasks
+from langgraph_api.grpc.client import get_shared_client
 from langgraph_api.js.base import is_js_path
+from langgraph_api.timing import profiled_import
 from langgraph_api.validation import DOCS_HTML
-from langgraph_runtime.database import connect, healthcheck
+from langgraph_runtime.database import healthcheck
 
 logger = structlog.stdlib.get_logger(__name__)
 
 
+async def grpc_healthcheck():
+    """Check the health of the gRPC server."""
+    try:
+        client = await get_shared_client()
+        await client.healthcheck()
+    except Exception as exc:
+        logger.warning(
+            "gRPC health check failed. Either the gRPC server is not running or is not responding.",
+            error=exc,
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="gRPC health check failed. Either the gRPC server is not running or is not responding.",
+        ) from exc
+
+
 async def ok(request: Request, *, disabled: bool = False):
     if disabled:
         # We still expose an /ok endpoint even if disable_meta is set so that
         # the operator knows the server started up.
         return JSONResponse({"ok": True})
     check_db = int(request.query_params.get("check_db", "0"))  # must be "0" or "1"
+
+    healthcheck_coroutines = []
+
     if check_db:
-        await healthcheck()
+        healthcheck_coroutines.append(healthcheck())
+
     if js_bg_tasks:
         from langgraph_api.js.remote import js_healthcheck
 
-        await js_healthcheck()
+        healthcheck_coroutines.append(js_healthcheck())
+
+    # Check `core-api` server health
+    if IS_POSTGRES_OR_GRPC_BACKEND:
+        healthcheck_coroutines.append(grpc_healthcheck())
+
+    await asyncio.gather(*healthcheck_coroutines)
+
     return JSONResponse({"ok": True})
 
 
@@ -54,6 +94,7 @@ async def docs(request: Request):
 
 
 shadowable_meta_routes: list[BaseRoute] = [
+    Route("/", ok, methods=["GET"]),  # Root health check for load balancers
     Route("/info", meta_info, methods=["GET"]),
 ]
 unshadowable_meta_routes: list[BaseRoute] = [
@@ -64,6 +105,13 @@ unshadowable_meta_routes: list[BaseRoute] = [
 ]
 
 middleware_for_protected_routes = [auth_middleware]
+
+# Add encryption context middleware if encryption is configured
+if LANGGRAPH_ENCRYPTION:
+    from langgraph_api.encryption.middleware import EncryptionContextMiddleware
+
+    middleware_for_protected_routes.append(Middleware(EncryptionContextMiddleware))
+
 protected_routes: list[BaseRoute] = []
 
 if HTTP_CONFIG:
@@ -75,6 +123,8 @@ if HTTP_CONFIG:
         protected_routes.extend(threads_routes)
     if not HTTP_CONFIG.get("disable_store"):
         protected_routes.extend(store_routes)
+    if FF_PYSPY_PROFILING_ENABLED:
+        protected_routes.extend(profile_routes)
     if not HTTP_CONFIG.get("disable_ui"):
         protected_routes.extend(ui_routes)
     if not HTTP_CONFIG.get("disable_mcp"):
@@ -86,14 +136,30 @@ else:
     protected_routes.extend(runs_routes)
     protected_routes.extend(threads_routes)
     protected_routes.extend(store_routes)
+    if FF_PYSPY_PROFILING_ENABLED:
+        protected_routes.extend(profile_routes)
     protected_routes.extend(ui_routes)
     protected_routes.extend(mcp_routes)
     protected_routes.extend(a2a_routes)
 
 
+def _metadata_fn(app_import: str) -> dict[str, str]:
+    return {"app": app_import}
+
+
+@timing.timer(
+    message="Loaded custom app from {app}",
+    metadata_fn=_metadata_fn,
+    warn_threshold_secs=3,
+    warn_message=(
+        "Import for custom app {app} exceeded the expected startup time. "
+        "Slow initialization (often due to work executed at import time) can delay readiness, "
+        "reduce scale-out capacity, and may cause deployments to be marked unhealthy."
+    ),
+    error_threshold_secs=30,
+)
 def load_custom_app(app_import: str) -> Starlette | None:
     # Expect a string in either "path/to/file.py:my_variable" or "some.module.in:my_variable"
-    logger.info(f"Loading custom app from {app_import}")
     path, name = app_import.rsplit(":", 1)
 
     # skip loading custom app if it's a js path
@@ -103,16 +169,19 @@ def load_custom_app(app_import: str) -> Starlette | None:
 
     try:
         os.environ["__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT"] = "true"
-        if os.path.isfile(path) or path.endswith(".py"):
-            # Import from file path using a unique module name.
-            spec = importlib.util.spec_from_file_location("user_router_module", path)
-            if spec is None or spec.loader is None:
-                raise ImportError(f"Cannot load spec from {path}")
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-        else:
-            # Import as a normal module.
-            module = importlib.import_module(path)
+        with profiled_import(app_import):
+            if os.path.isfile(path) or path.endswith(".py"):
+                # Import from file path using a unique module name.
+                spec = importlib.util.spec_from_file_location(
+                    "user_router_module", path
+                )
+                if spec is None or spec.loader is None:
+                    raise ImportError(f"Cannot load spec from {path}")
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+            else:
+                # Import as a normal module.
+                module = importlib.import_module(path)
         user_router = getattr(module, name)
         if not isinstance(user_router, Starlette):
             raise TypeError(
@@ -142,18 +211,15 @@ if HTTP_CONFIG:
 
     if router_import := HTTP_CONFIG.get("app"):
         user_router = load_custom_app(router_import)
+        if user_router:
+            user_router.router.lifespan_context = timing.wrap_lifespan_context_aenter(
+                user_router.router.lifespan_context,
+            )
 
 
-if "inmem" in MIGRATIONS_PATH:
-
-    async def truncate(request: Request):
-        from langgraph_runtime.checkpoint import Checkpointer
-
-        await asyncio.to_thread(Checkpointer().clear)
-        async with connect() as conn:
-            await asyncio.to_thread(conn.clear)
-        return JSONResponse({"ok": True})
+if "__inmem" in MIGRATIONS_PATH:
+    from langgraph_runtime_inmem.routes import get_internal_routes
 
-    unshadowable_meta_routes.insert(
-        0, Route("/internal/truncate", truncate, methods=["POST"])
-    )
+    if get_internal_routes is not None:
+        for route in get_internal_routes():
+            unshadowable_meta_routes.insert(0, route)

langgraph_api/api/a2a.py

@@ -10,6 +10,7 @@ The implementation currently supports JSON-RPC 2.0 transport only.
 Push notifications are not implemented.
 """
 
+import asyncio
 import functools
 import uuid
 from datetime import UTC, datetime
@@ -276,9 +277,7 @@ def _extract_a2a_response(result: dict[str, Any]) -> str:
             isinstance(message, dict)
             and message.get("role") == "assistant"
             and "content" in message
-            or message.get("type") == "ai"
-            and "content" in message
-        ):
+        ) or (message.get("type") == "ai" and "content" in message):
             return message["content"]
 
     # If no assistant message found, return the last message content
@@ -446,7 +445,7 @@ def _map_runs_create_error_to_rpc(
     return {
         "error": {
             "code": ERROR_CODE_INTERNAL_ERROR,
-            "message": f"Internal server error: {str(exception)}",
+            "message": f"Internal server error: {exception!s}",
         }
     }
 
@@ -502,7 +501,7 @@ def _map_runs_get_error_to_rpc(
     return {
         "error": {
             "code": ERROR_CODE_INTERNAL_ERROR,
-            "message": f"Internal server error: {str(exception)}",
+            "message": f"Internal server error: {exception!s}",
         }
     }
 
@@ -687,14 +686,14 @@ async def handle_post_request(request: ApiRequest, assistant_id: str) -> Respons
     if id_ is not None and method:
         # JSON-RPC request
         return await handle_jsonrpc_request(
-            request, cast(JsonRpcRequest, message), assistant_id
+            request, cast("JsonRpcRequest", message), assistant_id
         )
     elif id_ is not None:
         # JSON-RPC response (not expected in A2A server context)
         return handle_jsonrpc_response()
     elif method:
         # JSON-RPC notification
-        return handle_jsonrpc_notification(cast(JsonRpcNotification, message))
+        return handle_jsonrpc_notification(cast("JsonRpcNotification", message))
     else:
         return create_error_response(
             "Invalid message format. Message must be a JSON-RPC request, "
@@ -926,7 +925,7 @@ async def handle_message_send(
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {str(e)}",
+                "message": f"Internal server error: {e!s}",
             }
         }
 
@@ -1020,10 +1019,17 @@ async def handle_tasks_get(
                 }
 
         try:
-            run_info = await client.runs.get(
-                thread_id=context_id,
-                run_id=task_id,
-                headers=request.headers,
+            # TODO: fix the N+1 query issue
+            run_info, thread_info = await asyncio.gather(
+                client.runs.get(
+                    thread_id=context_id,
+                    run_id=task_id,
+                    headers=request.headers,
+                ),
+                client.threads.get(
+                    thread_id=context_id,
+                    headers=request.headers,
+                ),
             )
         except Exception as e:
             error_response = _map_runs_get_error_to_rpc(e, task_id, context_id)
@@ -1032,19 +1038,6 @@ async def handle_tasks_get(
                 raise
             return error_response
 
-        assistant_id = run_info.get("assistant_id")
-        if assistant_id:
-            try:
-                # Verify that the assistant exists
-                await _get_assistant(assistant_id, request.headers)
-            except ValueError as e:
-                return {
-                    "error": {
-                        "code": ERROR_CODE_INVALID_PARAMS,
-                        "message": str(e),
-                    }
-                }
-
         lg_status = run_info.get("status", "unknown")
 
         if lg_status == "pending":
@@ -1052,8 +1045,18 @@ async def handle_tasks_get(
         elif lg_status == "running":
             a2a_state = "working"
         elif lg_status == "success":
-            a2a_state = "completed"
-        elif lg_status in ["error", "timeout", "interrupted"]:
+            # Hack hack: if the thread **at present** is interrupted, assume
+            # the run also is interrupted
+            if thread_info.get("status") == "interrupted":
+                a2a_state = "input-required"
+            else:
+                # Inspect whether there are next tasks
+                a2a_state = "completed"
+        elif (
+            lg_status == "interrupted"
+        ):  # Note that this is if you interrupt FROM the outside (i.e., with double texting)
+            a2a_state = "input-required"
+        elif lg_status in ["error", "timeout"]:
             a2a_state = "failed"
         else:
             a2a_state = "submitted"
@@ -1103,12 +1106,12 @@ async def handle_tasks_get(
 
     except Exception as e:
         await logger.aerror(
-            f"Error in tasks/get for task {params.get('id')}: {str(e)}", exc_info=True
+            f"Error in tasks/get for task {params.get('id')}: {e!s}", exc_info=True
         )
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {str(e)}",
+                "message": f"Internal server error: {e!s}",
             }
         }
 
@@ -1149,6 +1152,7 @@ async def handle_tasks_cancel(
 # ============================================================================
 
 
+# TODO: add routes for /a2a/agents/{id}/card
 async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[str, Any]:
     """Generate A2A Agent Card for a specific assistant.
 
@@ -1279,7 +1283,7 @@ async def handle_agent_card_endpoint(request: ApiRequest) -> Response:
         error_response = {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {str(e)}",
+                "message": f"Internal server error: {e!s}",
             }
         }
         return Response(
@@ -1537,7 +1541,7 @@ async def handle_message_stream(
             yield (b"message", {"jsonrpc": "2.0", "id": rpc_id, "result": fallback})
         except Exception as e:
             await logger.aerror(
-                f"Error in message/stream for assistant {assistant_id}: {str(e)}",
+                f"Error in message/stream for assistant {assistant_id}: {e!s}",
                 exc_info=True,
             )
             yield (
@@ -1547,7 +1551,7 @@ async def handle_message_stream(
                     "id": rpc_id,
                     "error": {
                         "code": ERROR_CODE_INTERNAL_ERROR,
-                        "message": f"Internal server error: {str(e)}",
+                        "message": f"Internal server error: {e!s}",
                     },
                 },
             )

langgraph_api/api/assistants.py

@@ -14,12 +14,20 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api import store as api_store
-from langgraph_api.feature_flags import FF_USE_CORE_API, 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.ops import Assistants as GrpcAssistants
+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.schema import ASSISTANT_ENCRYPTION_FIELDS, ASSISTANT_FIELDS
 from langgraph_api.serde import json_loads
 from langgraph_api.utils import (
     fetchone,
@@ -39,14 +47,18 @@ from langgraph_api.validation import (
 )
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.database import connect as base_connect
-from langgraph_runtime.ops import Assistants
 from langgraph_runtime.retry import retry_db
 
 logger = structlog.stdlib.get_logger(__name__)
 
-CrudAssistants = GrpcAssistants if FF_USE_CORE_API else Assistants
+if IS_POSTGRES_OR_GRPC_BACKEND:
+    CrudAssistants = GrpcAssistants
+else:
+    from langgraph_runtime.ops import Assistants
 
-connect = partial(base_connect, supports_core_api=FF_USE_CORE_API)
+    CrudAssistants = Assistants
+
+connect = partial(base_connect, supports_core_api=IS_POSTGRES_OR_GRPC_BACKEND)
 
 EXCLUDED_CONFIG_SCHEMA = (
     "__pregel_checkpointer",
@@ -118,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
 
@@ -140,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
 
@@ -149,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:
@@ -176,20 +188,34 @@ async def create_assistant(request: ApiRequest) -> ApiResponse:
             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 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
@@ -210,6 +236,7 @@ async def search_assistants(
         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,
@@ -220,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
@@ -233,6 +268,7 @@ async def count_assistants(
         count = await CrudAssistants.count(
             conn,
             graph_id=payload.get("graph_id"),
+            name=payload.get("name"),
             metadata=payload.get("metadata"),
         )
     return ApiResponse(count)
@@ -247,7 +283,15 @@ async def get_assistant(
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
         assistant = await CrudAssistants.get(conn, assistant_id)
-    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
@@ -269,6 +313,7 @@ async def get_assistant_graph(
         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")
@@ -326,6 +371,7 @@ async def get_assistant_subgraphs(
         config,
         checkpointer=Checkpointer(),
         store=(await api_store.get_store()),
+        is_for_execution=False,
     ) as graph:
         namespace = request.path_params.get("namespace")
 
@@ -374,6 +420,7 @@ async def get_assistant_schemas(
         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()
@@ -412,27 +459,52 @@ async def patch_assistant(
             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 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 CrudAssistants.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)
 
@@ -456,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
@@ -469,7 +549,15 @@ async def set_latest_assistant_version(request: ApiRequest) -> ApiResponse:
         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] = [