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

langgraph_api/api/runs.py

@@ -1,17 +1,33 @@
 import asyncio
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Awaitable, Callable
 from typing import Literal, cast
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 import orjson
+import structlog
 from starlette.exceptions import HTTPException
 from starlette.responses import Response, StreamingResponse
 
 from langgraph_api import config
-from langgraph_api.asyncio import ValueEvent, aclosing
+from langgraph_api.asyncio import ValueEvent
+from langgraph_api.encryption.middleware import (
+    decrypt_response,
+    decrypt_responses,
+    encrypt_request,
+)
+from langgraph_api.feature_flags import FF_USE_CORE_API
+from langgraph_api.graph import _validate_assistant_id
+from langgraph_api.grpc.ops import Runs as GrpcRuns
 from langgraph_api.models.run import create_valid_run
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
-from langgraph_api.schema import CRON_FIELDS, RUN_FIELDS
+from langgraph_api.schema import (
+    CRON_ENCRYPTION_FIELDS,
+    CRON_FIELDS,
+    CRON_PAYLOAD_ENCRYPTION_SUBFIELDS,
+    RUN_ENCRYPTION_FIELDS,
+    RUN_FIELDS,
+)
+from langgraph_api.serde import json_dumpb, json_loads
 from langgraph_api.sse import EventSourceResponse
 from langgraph_api.utils import (
     fetchone,
@@ -28,18 +44,138 @@ from langgraph_api.validation import (
     RunCreateStateful,
     RunCreateStateless,
     RunsCancel,
+    ThreadCronCreate,
 )
+from langgraph_api.webhook import validate_webhook_url_or_raise
 from langgraph_license.validation import plus_features_enabled
 from langgraph_runtime.database import connect
-from langgraph_runtime.ops import Crons, Runs, Threads
+from langgraph_runtime.ops import Crons, Runs, StreamHandler, Threads
 from langgraph_runtime.retry import retry_db
 
+CrudRuns = GrpcRuns if FF_USE_CORE_API else Runs
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+_RunResultFallback = Callable[[], Awaitable[bytes]]
+
+
+def _ensure_crons_enabled() -> None:
+    if not (config.FF_CRONS_ENABLED and plus_features_enabled()):
+        raise HTTPException(
+            status_code=403,
+            detail="Crons are currently only available in the cloud version of LangSmith Deployment or with a self-hosting enterprise license. Please visit https://docs.langchain.com/langsmith/deployments to learn more about deployment options, or contact sales@langchain.com for more information",
+        )
+
+
+def _thread_values_fallback(thread_id: UUID) -> _RunResultFallback:
+    async def fetch_thread_values() -> bytes:
+        async with connect() as conn:
+            thread_iter = await Threads.get(conn, thread_id)
+            try:
+                row = await anext(thread_iter)
+                # Decrypt thread fields (values, interrupts, error) if encryption is enabled
+                thread = await decrypt_response(
+                    dict(row),
+                    "thread",
+                    ["values", "interrupts", "error"],
+                )
+                if row["status"] == "error":
+                    return json_dumpb({"__error__": json_loads(thread["error"])})
+                if row["status"] == "interrupted":
+                    # Get an interrupt for the thread. There is the case where there are multiple interrupts for the same run and we may not show the same
+                    # interrupt, but we'll always show one. Long term we should show all of them.
+                    try:
+                        interrupt_map = json_loads(thread["interrupts"])
+                        interrupt = [next(iter(interrupt_map.values()))[0]]
+                        return json_dumpb({"__interrupt__": interrupt})
+                    except Exception:
+                        # No interrupt, but status is interrupted from a before/after block. Default back to values.
+                        pass
+                values = json_loads(thread["values"]) if thread["values"] else None
+                return json_dumpb(values) if values else b"{}"
+            except StopAsyncIteration:
+                await logger.awarning(
+                    f"No checkpoint found for thread {thread_id}",
+                    thread_id=thread_id,
+                )
+                return b"{}"
+
+    return fetch_thread_values
+
+
+def _run_result_body(
+    *,
+    run_id: UUID,
+    thread_id: UUID,
+    sub: StreamHandler,
+    cancel_on_disconnect: bool = False,
+    ignore_404: bool = False,
+    fallback: _RunResultFallback | None = None,
+    cancel_message: str | None = None,
+) -> Callable[[], AsyncIterator[bytes]]:
+    last_chunk = ValueEvent()
+
+    async def consume() -> None:
+        vchunk: bytes | None = None
+        try:
+            async for mode, chunk, _ in Runs.Stream.join(
+                run_id,
+                stream_channel=sub,
+                cancel_on_disconnect=cancel_on_disconnect,
+                thread_id=thread_id,
+                ignore_404=ignore_404,
+            ):
+                if mode == b"values" or (
+                    mode == b"updates" and b"__interrupt__" in chunk
+                ):
+                    vchunk = chunk
+                elif mode == b"error":
+                    vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
+            if vchunk is not None:
+                last_chunk.set(vchunk)
+            elif fallback is not None:
+                last_chunk.set(await fallback())
+            else:
+                last_chunk.set(b"{}")
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
+    # keep the connection open by sending whitespace every 5 seconds
+    # leading whitespace will be ignored by json parsers
+    async def body() -> AsyncIterator[bytes]:
+        try:
+            stream = asyncio.create_task(consume())
+            while True:
+                try:
+                    if stream.done():
+                        # raise stream exception if any
+                        stream.result()
+                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
+                    break
+                except TimeoutError:
+                    yield b"\n"
+                except asyncio.CancelledError:
+                    if cancel_message is not None:
+                        stream.cancel(cancel_message)
+                    else:
+                        stream.cancel()
+                    await stream
+                    raise
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
+    return body
+
 
 @retry_db
 async def create_run(request: ApiRequest):
     """Create a run."""
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
+
     async with connect() as conn:
         run = await create_valid_run(
             conn,
@@ -48,6 +184,7 @@ async def create_run(request: ApiRequest):
             request.headers,
             request_start_time=request.scope.get("request_start_time_ms"),
         )
+    run = await decrypt_response(run, "run", RUN_ENCRYPTION_FIELDS)
     return ApiResponse(
         run,
         headers={"Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}"},
@@ -58,6 +195,7 @@ async def create_run(request: ApiRequest):
 async def create_stateless_run(request: ApiRequest):
     """Create a run."""
     payload = await request.json(RunCreateStateless)
+
     async with connect() as conn:
         run = await create_valid_run(
             conn,
@@ -66,6 +204,7 @@ async def create_stateless_run(request: ApiRequest):
             request.headers,
             request_start_time=request.scope.get("request_start_time_ms"),
         )
+    run = await decrypt_response(run, "run", RUN_ENCRYPTION_FIELDS)
     return ApiResponse(
         run,
         headers={"Content-Location": f"/runs/{run['run_id']}"},
@@ -90,6 +229,7 @@ async def create_stateless_run_batch(request: ApiRequest):
             for payload in batch_payload
         ]
         runs = await asyncio.gather(*coros)
+    runs = await decrypt_responses(list(runs), "run", RUN_ENCRYPTION_FIELDS)
     return ApiResponse(runs)
 
 
@@ -101,8 +241,8 @@ async def stream_run(
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
 
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
     try:
         async with connect() as conn:
             run = await create_valid_run(
@@ -114,19 +254,26 @@ async def stream_run(
                 request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
+        # Clean up the pubsub on errors
+        await sub.__aexit__(None, None, None)
         raise
 
+    async def body():
+        try:
+            async for event, message, stream_id in Runs.Stream.join(
+                run["run_id"],
+                thread_id=thread_id,
+                cancel_on_disconnect=on_disconnect == "cancel",
+                stream_channel=sub,
+                last_event_id=None,
+            ):
+                yield event, message, stream_id
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
     return EventSourceResponse(
-        Runs.Stream.join(
-            run["run_id"],
-            thread_id=thread_id,
-            cancel_on_disconnect=on_disconnect == "cancel",
-            stream_channel=await sub,
-            last_event_id=None,
-        ),
+        body(),
         headers={
             "Location": f"/threads/{thread_id}/runs/{run['run_id']}/stream",
             "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
@@ -143,7 +290,8 @@ async def stream_run_stateless(
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
     thread_id = uuid4()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
+
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
     try:
         async with connect() as conn:
             run = await create_valid_run(
@@ -156,20 +304,27 @@ async def stream_run_stateless(
                 temporary=True,
             )
     except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
+        # Clean up the pubsub on errors
+        await sub.__aexit__(None, None, None)
         raise
 
+    async def body():
+        try:
+            async for event, message, stream_id in Runs.Stream.join(
+                run["run_id"],
+                thread_id=run["thread_id"],
+                ignore_404=True,
+                cancel_on_disconnect=on_disconnect == "cancel",
+                stream_channel=sub,
+                last_event_id=None,
+            ):
+                yield event, message, stream_id
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
     return EventSourceResponse(
-        Runs.Stream.join(
-            run["run_id"],
-            thread_id=run["thread_id"],
-            ignore_404=True,
-            cancel_on_disconnect=on_disconnect == "cancel",
-            stream_channel=await sub,
-            last_event_id=None,
-        ),
+        body(),
         headers={
             "Location": f"/runs/{run['run_id']}/stream",
             "Content-Location": f"/runs/{run['run_id']}",
@@ -184,8 +339,7 @@ async def wait_run(request: ApiRequest):
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
-
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
     try:
         async with connect() as conn:
             run = await create_valid_run(
@@ -197,60 +351,17 @@ async def wait_run(request: ApiRequest):
                 request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
+        # Clean up the pubsub on errors
+        await sub.__aexit__(None, None, None)
         raise
 
-    last_chunk = ValueEvent()
-
-    async def consume():
-        vchunk: bytes | None = None
-        async with aclosing(
-            Runs.Stream.join(
-                run["run_id"],
-                thread_id=run["thread_id"],
-                stream_channel=await sub,
-                cancel_on_disconnect=on_disconnect == "cancel",
-            )
-        ) as stream:
-            async for mode, chunk, _ in stream:
-                if (
-                    mode == b"values"
-                    or mode == b"updates"
-                    and b"__interrupt__" in chunk
-                ):
-                    vchunk = chunk
-                elif mode == b"error":
-                    vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            async with connect() as conn:
-                thread_iter = await Threads.get(conn, thread_id)
-                try:
-                    thread = await anext(thread_iter)
-                    last_chunk.set(thread["values"])
-                except StopAsyncIteration:
-                    last_chunk.set(b"{}")
-
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        stream = asyncio.create_task(consume())
-        while True:
-            try:
-                if stream.done():
-                    # raise stream exception if any
-                    stream.result()
-                yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                break
-            except TimeoutError:
-                yield b"\n"
-            except asyncio.CancelledError:
-                stream.cancel()
-                await stream
-                raise
+    body = _run_result_body(
+        run_id=run["run_id"],
+        thread_id=run["thread_id"],
+        sub=sub,
+        cancel_on_disconnect=on_disconnect == "cancel",
+        fallback=_thread_values_fallback(thread_id),
+    )
 
     return StreamingResponse(
         body(),
@@ -270,8 +381,8 @@ async def wait_run_stateless(request: ApiRequest):
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
     thread_id = uuid4()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
 
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
     try:
         async with connect() as conn:
             run = await create_valid_run(
@@ -284,55 +395,27 @@ async def wait_run_stateless(request: ApiRequest):
                 temporary=True,
             )
     except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
+        # Clean up the pubsub on errors
+        await sub.__aexit__(None, None, None)
         raise
-    last_chunk = ValueEvent()
-
-    async def consume():
-        vchunk: bytes | None = None
-        async with aclosing(
-            Runs.Stream.join(
-                run["run_id"],
-                thread_id=run["thread_id"],
-                stream_channel=await sub,
-                ignore_404=True,
-                cancel_on_disconnect=on_disconnect == "cancel",
-            )
-        ) as stream:
-            async for mode, chunk, _ in stream:
-                if (
-                    mode == b"values"
-                    or mode == b"updates"
-                    and b"__interrupt__" in chunk
-                ):
-                    vchunk = chunk
-                elif mode == b"error":
-                    vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            # we can't fetch the thread (it was deleted), so just return empty values
-            last_chunk.set(b"{}")
 
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        stream = asyncio.create_task(consume())
-        while True:
-            try:
-                if stream.done():
-                    # raise stream exception if any
-                    stream.result()
-                yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                break
-            except TimeoutError:
-                yield b"\n"
-            except asyncio.CancelledError:
-                stream.cancel("Run stream cancelled")
-                await stream
-                raise
+    async def stateless_fallback() -> bytes:
+        await logger.awarning(
+            "No checkpoint emitted for stateless run",
+            run_id=run["run_id"],
+            thread_id=run["thread_id"],
+        )
+        return b"{}"
+
+    body = _run_result_body(
+        run_id=run["run_id"],
+        thread_id=run["thread_id"],
+        sub=sub,
+        cancel_on_disconnect=on_disconnect == "cancel",
+        ignore_404=True,
+        fallback=stateless_fallback,
+        cancel_message="Run stream cancelled",
+    )
 
     return StreamingResponse(
         body(),
@@ -361,7 +444,7 @@ async def list_runs(
     async with connect() as conn, conn.pipeline():
         thread, runs = await asyncio.gather(
             Threads.get(conn, thread_id),
-            Runs.search(
+            CrudRuns.search(
                 conn,
                 thread_id,
                 limit=limit,
@@ -371,7 +454,12 @@ async def list_runs(
             ),
         )
     await fetchone(thread)
-    return ApiResponse([run async for run in runs])
+
+    # Collect and decrypt runs
+    runs_list = [run async for run in runs]
+    runs_list = await decrypt_responses(runs_list, "run", RUN_ENCRYPTION_FIELDS)
+
+    return ApiResponse(runs_list)
 
 
 @retry_db
@@ -385,14 +473,19 @@ async def get_run(request: ApiRequest):
     async with connect() as conn, conn.pipeline():
         thread, run = await asyncio.gather(
             Threads.get(conn, thread_id),
-            Runs.get(
+            CrudRuns.get(
                 conn,
                 run_id,
                 thread_id=thread_id,
             ),
         )
     await fetchone(thread)
-    return ApiResponse(await fetchone(run))
+    run_dict = await fetchone(run)
+
+    # Decrypt run metadata and kwargs
+    run_dict = await decrypt_response(run_dict, "run", RUN_ENCRYPTION_FIELDS)
+
+    return ApiResponse(run_dict)
 
 
 @retry_db
@@ -403,11 +496,23 @@ async def join_run(request: ApiRequest):
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
 
-    return ApiResponse(
-        await Runs.join(
-            run_id,
-            thread_id=thread_id,
-        )
+    # A touch redundant, but to meet the existing signature of join, we need to throw any 404s before we enter the streaming body
+    await Runs.Stream.check_run_stream_auth(run_id, thread_id)
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
+    body = _run_result_body(
+        run_id=run_id,
+        thread_id=thread_id,
+        sub=sub,
+        fallback=_thread_values_fallback(thread_id),
+    )
+
+    return StreamingResponse(
+        body(),
+        media_type="application/json",
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/join",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
     )
 
 
@@ -422,14 +527,25 @@ async def join_run_stream(request: ApiRequest):
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
     stream_mode = request.query_params.get("stream_mode") or []
     last_event_id = request.headers.get("last-event-id") or None
+
+    async def body():
+        async with await Runs.Stream.subscribe(run_id, thread_id) as sub:
+            async for event, message, stream_id in Runs.Stream.join(
+                run_id,
+                thread_id=thread_id,
+                cancel_on_disconnect=cancel_on_disconnect,
+                stream_channel=sub,
+                stream_mode=stream_mode,
+                last_event_id=last_event_id,
+            ):
+                yield event, message, stream_id
+
     return EventSourceResponse(
-        Runs.Stream.join(
-            run_id,
-            thread_id=thread_id,
-            cancel_on_disconnect=cancel_on_disconnect,
-            stream_mode=stream_mode,
-            last_event_id=last_event_id,
-        ),
+        body(),
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/stream",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
     )
 
 
@@ -446,23 +562,40 @@ async def cancel_run(
     wait = wait_str.lower() in {"true", "yes", "1"}
     action_str = request.query_params.get("action", "interrupt")
     action = cast(
-        Literal["interrupt", "rollback"],
+        "Literal['interrupt', 'rollback']",
         action_str if action_str in {"interrupt", "rollback"} else "interrupt",
     )
 
-    async with connect() as conn:
-        await Runs.cancel(
-            conn,
-            [run_id],
-            action=action,
-            thread_id=thread_id,
-        )
-    if wait:
-        await Runs.join(
-            run_id,
-            thread_id=thread_id,
-        )
-    return Response(status_code=204 if wait else 202)
+    sub = await Runs.Stream.subscribe(run_id, thread_id) if wait else None
+    try:
+        async with connect() as conn:
+            await CrudRuns.cancel(
+                conn,
+                [run_id],
+                action=action,
+                thread_id=thread_id,
+            )
+    except Exception:
+        if sub is not None:
+            await sub.__aexit__(None, None, None)
+        raise
+    if not wait:
+        return Response(status_code=202)
+
+    body = _run_result_body(
+        run_id=run_id,
+        thread_id=thread_id,
+        sub=sub,
+    )
+
+    return StreamingResponse(
+        body(),
+        media_type="application/json",
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/join",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
+    )
 
 
 @retry_db
@@ -495,12 +628,12 @@ async def cancel_runs(
             validate_uuid(rid, "Invalid run ID: must be a UUID")
     action_str = request.query_params.get("action", "interrupt")
     action = cast(
-        Literal["interrupt", "rollback"],
+        "Literal['interrupt', 'rollback']",
         action_str if action_str in ("interrupt", "rollback") else "interrupt",
     )
 
     async with connect() as conn:
-        await Runs.cancel(
+        await CrudRuns.cancel(
             conn,
             run_ids,
             action=action,
@@ -519,7 +652,7 @@ async def delete_run(request: ApiRequest):
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
 
     async with connect() as conn:
-        rid = await Runs.delete(
+        rid = await CrudRuns.delete(
             conn,
             run_id,
             thread_id=thread_id,
@@ -531,40 +664,71 @@ async def delete_run(request: ApiRequest):
 @retry_db
 async def create_cron(request: ApiRequest):
     """Create a cron with new thread."""
+    _ensure_crons_enabled()
     payload = await request.json(CronCreate)
+    if webhook := payload.get("webhook"):
+        await validate_webhook_url_or_raise(str(webhook))
+    _validate_assistant_id(payload.get("assistant_id"))
+
+    encrypted_payload = await encrypt_request(
+        payload,
+        "cron",
+        CRON_PAYLOAD_ENCRYPTION_SUBFIELDS,
+    )
 
     async with connect() as conn:
         cron = await Crons.put(
             conn,
             thread_id=None,
+            on_run_completed=payload.get("on_run_completed", "delete"),
             end_time=payload.get("end_time"),
             schedule=payload.get("schedule"),
-            payload=payload,
+            payload=encrypted_payload,
+            metadata=encrypted_payload.get("metadata"),
         )
-    return ApiResponse(await fetchone(cron))
+    cron_dict = await fetchone(cron)
+    cron_dict = await decrypt_response(cron_dict, "cron", CRON_ENCRYPTION_FIELDS)
+
+    return ApiResponse(cron_dict)
 
 
 @retry_db
 async def create_thread_cron(request: ApiRequest):
     """Create a thread specific cron."""
+    _ensure_crons_enabled()
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
-    payload = await request.json(CronCreate)
+    payload = await request.json(ThreadCronCreate)
+    if webhook := payload.get("webhook"):
+        await validate_webhook_url_or_raise(str(webhook))
+    _validate_assistant_id(payload.get("assistant_id"))
+
+    encrypted_payload = await encrypt_request(
+        payload,
+        "cron",
+        CRON_PAYLOAD_ENCRYPTION_SUBFIELDS,
+    )
 
     async with connect() as conn:
         cron = await Crons.put(
             conn,
             thread_id=thread_id,
+            on_run_completed=None,
             end_time=payload.get("end_time"),
             schedule=payload.get("schedule"),
-            payload=payload,
+            payload=encrypted_payload,
+            metadata=encrypted_payload.get("metadata"),
         )
-    return ApiResponse(await fetchone(cron))
+    cron_dict = await fetchone(cron)
+    cron_dict = await decrypt_response(cron_dict, "cron", CRON_ENCRYPTION_FIELDS)
+
+    return ApiResponse(cron_dict)
 
 
 @retry_db
 async def delete_cron(request: ApiRequest):
     """Delete a cron by ID."""
+    _ensure_crons_enabled()
     cron_id = request.path_params["cron_id"]
     validate_uuid(cron_id, "Invalid cron ID: must be a UUID")
 
@@ -580,6 +744,7 @@ async def delete_cron(request: ApiRequest):
 @retry_db
 async def search_crons(request: ApiRequest):
     """List all cron jobs for an assistant"""
+    _ensure_crons_enabled()
     payload = await request.json(CronSearch)
     select = validate_select_columns(payload.get("select") or None, CRON_FIELDS)
     if assistant_id := payload.get("assistant_id"):
@@ -602,12 +767,16 @@ async def search_crons(request: ApiRequest):
     crons, response_headers = await get_pagination_headers(
         crons_iter, next_offset, offset
     )
+
+    crons = await decrypt_responses(crons, "cron", CRON_ENCRYPTION_FIELDS)
+
     return ApiResponse(crons, headers=response_headers)
 
 
 @retry_db
 async def count_crons(request: ApiRequest):
     """Count cron jobs."""
+    _ensure_crons_enabled()
     payload = await request.json(CronCountRequest)
     if assistant_id := payload.get("assistant_id"):
         validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
@@ -629,21 +798,9 @@ runs_routes = [
     ApiRoute("/runs", create_stateless_run, methods=["POST"]),
     ApiRoute("/runs/batch", create_stateless_run_batch, methods=["POST"]),
     ApiRoute("/runs/cancel", cancel_runs, methods=["POST"]),
-    (
-        ApiRoute("/runs/crons", create_cron, methods=["POST"])
-        if config.FF_CRONS_ENABLED and plus_features_enabled()
-        else None
-    ),
-    (
-        ApiRoute("/runs/crons/search", search_crons, methods=["POST"])
-        if config.FF_CRONS_ENABLED and plus_features_enabled()
-        else None
-    ),
-    (
-        ApiRoute("/runs/crons/count", count_crons, methods=["POST"])
-        if config.FF_CRONS_ENABLED and plus_features_enabled()
-        else None
-    ),
+    ApiRoute("/runs/crons", create_cron, methods=["POST"]),
+    ApiRoute("/runs/crons/search", search_crons, methods=["POST"]),
+    ApiRoute("/runs/crons/count", count_crons, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs/{run_id}/join", join_run, methods=["GET"]),
     ApiRoute(
         "/threads/{thread_id}/runs/{run_id}/stream",
@@ -656,19 +813,9 @@ runs_routes = [
     ApiRoute("/threads/{thread_id}/runs/stream", stream_run, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs/wait", wait_run, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs", create_run, methods=["POST"]),
-    (
-        ApiRoute(
-            "/threads/{thread_id}/runs/crons", create_thread_cron, methods=["POST"]
-        )
-        if config.FF_CRONS_ENABLED and plus_features_enabled()
-        else None
-    ),
+    ApiRoute("/threads/{thread_id}/runs/crons", create_thread_cron, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs", list_runs, methods=["GET"]),
-    (
-        ApiRoute("/runs/crons/{cron_id}", delete_cron, methods=["DELETE"])
-        if config.FF_CRONS_ENABLED and plus_features_enabled()
-        else None
-    ),
+    ApiRoute("/runs/crons/{cron_id}", delete_cron, methods=["DELETE"]),
 ]
 
 runs_routes = [route for route in runs_routes if route is not None]