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

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

@@ -3,6 +3,8 @@ 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
@@ -10,6 +12,8 @@ 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__)
@@ -66,7 +70,7 @@ 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:
@@ -76,7 +80,7 @@ async def meta_metrics(request: ApiRequest):
         metrics = []
         try:
             async with connect() as conn:
-                queue_stats = await Runs.stats(conn)
+                queue_stats = await CrudRuns.stats(conn)
 
                 metrics.extend(
                     [
@@ -86,6 +90,15 @@ async def meta_metrics(request: ApiRequest):
                         "# 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:

langgraph_api/api/openapi.py

@@ -5,12 +5,7 @@ from functools import lru_cache
 
 import orjson
 
-from langgraph_api.config import (
-    HTTP_CONFIG,
-    LANGGRAPH_AUTH,
-    LANGGRAPH_AUTH_TYPE,
-    MOUNT_PREFIX,
-)
+from langgraph_api import config
 from langgraph_api.graph import GRAPHS
 from langgraph_api.validation import openapi
 
@@ -39,17 +34,20 @@ def get_openapi_spec() -> bytes:
             graph_ids
         )
     # patch the auth schemes
-    if LANGGRAPH_AUTH_TYPE == "langsmith":
+    if config.LANGGRAPH_AUTH_TYPE == "langsmith":
         openapi["security"] = [
             {"x-api-key": []},
         ]
         openapi["components"]["securitySchemes"] = {
             "x-api-key": {"type": "apiKey", "in": "header", "name": "x-api-key"}
         }
-    if LANGGRAPH_AUTH:
+    if config.LANGGRAPH_AUTH:
         # Allow user to specify OpenAPI security configuration
-        if isinstance(LANGGRAPH_AUTH, dict) and "openapi" in LANGGRAPH_AUTH:
-            openapi_config = LANGGRAPH_AUTH["openapi"]
+        if (
+            isinstance(config.LANGGRAPH_AUTH, dict)
+            and "openapi" in config.LANGGRAPH_AUTH
+        ):
+            openapi_config = config.LANGGRAPH_AUTH["openapi"]
             if isinstance(openapi_config, dict):
                 # Add security schemes
                 if "securitySchemes" in openapi_config:
@@ -82,8 +80,13 @@ def get_openapi_spec() -> bytes:
             )
 
     # Remove webhook parameters if webhooks are disabled
-    if HTTP_CONFIG and HTTP_CONFIG.get("disable_webhooks"):
-        webhook_schemas = ["CronCreate", "RunCreateStateful", "RunCreateStateless"]
+    if config.WEBHOOKS_ENABLED:
+        webhook_schemas = [
+            "CronCreate",
+            "ThreadCronCreate",
+            "RunCreateStateful",
+            "RunCreateStateless",
+        ]
         for schema_name in webhook_schemas:
             if schema_name in openapi["components"]["schemas"]:
                 schema = openapi["components"]["schemas"][schema_name]
@@ -96,14 +99,21 @@ def get_openapi_spec() -> bytes:
     final = openapi
     if CUSTOM_OPENAPI_SPEC:
         final = merge_openapi_specs(openapi, CUSTOM_OPENAPI_SPEC)
-    if MOUNT_PREFIX:
-        final["servers"] = [{"url": MOUNT_PREFIX}]
-
-    MCP_ENABLED = HTTP_CONFIG is None or not HTTP_CONFIG.get("disable_mcp")
+    if config.MOUNT_PREFIX:
+        final["servers"] = [{"url": config.MOUNT_PREFIX}]
 
-    if not MCP_ENABLED:
+    if not config.MCP_ENABLED:
         # Remove the MCP paths from the OpenAPI spec
         final["paths"].pop("/mcp/", None)
+        # Remove the MCP tag definition
+        final["tags"] = [t for t in final.get("tags", []) if t.get("name") != "MCP"]
+
+    if not config.A2A_ENABLED:
+        # Remove the A2A paths from the OpenAPI spec
+        final["paths"].pop("/a2a/{assistant_id}", None)
+        final["paths"].pop("/.well-known/agent-card.json", None)
+        # Remove the A2A tag definition
+        final["tags"] = [t for t in final.get("tags", []) if t.get("name") != "A2A"]
 
     return orjson.dumps(final)
 

langgraph_api/api/profile.py

@@ -0,0 +1,108 @@
+import asyncio
+import contextlib
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+from typing import Literal
+
+import structlog
+from starlette.responses import JSONResponse, Response
+from starlette.routing import BaseRoute
+
+from langgraph_api import config
+from langgraph_api.route import ApiRequest, ApiRoute
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+def _clamp_duration(seconds: int) -> int:
+    seconds = max(1, seconds)
+    return min(seconds, max(1, config.FF_PYSPY_PROFILING_MAX_DURATION_SECS))
+
+
+async def _profile_with_pyspy(seconds: int, fmt: Literal["svg"]) -> Response:
+    """Run py-spy against the current process for N seconds and return SVG."""
+    pyspy = shutil.which("py-spy")
+    if not pyspy:
+        return JSONResponse({"error": "py-spy not found on PATH"}, status_code=501)
+
+    # py-spy writes to a file; use a temp file then return its contents.
+    fd, path = tempfile.mkstemp(suffix=".svg")
+    os.close(fd)
+    try:
+        pid = os.getpid()
+        # Example:
+        # py-spy record -p <pid> -d <seconds> --format flamegraph -o out.svg
+        cmd = [
+            pyspy,
+            "record",
+            "-p",
+            str(pid),
+            "-d",
+            str(seconds),
+            "--format",
+            "flamegraph",
+            "-o",
+            path,
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        try:
+            _, stderr = await asyncio.wait_for(proc.communicate(), timeout=seconds + 15)
+        except TimeoutError:
+            with contextlib.suppress(ProcessLookupError):
+                proc.kill()
+            return JSONResponse(
+                {
+                    "error": "py-spy timed out",
+                    "hint": "Check ptrace permissions or reduce duration",
+                },
+                status_code=504,
+            )
+        if proc.returncode != 0:
+            # Common failures: missing ptrace capability in containers.
+            msg = stderr.decode("utf-8", errors="ignore") if stderr else "py-spy failed"
+            await logger.awarning("py-spy failed", returncode=proc.returncode, msg=msg)
+            return JSONResponse(
+                {
+                    "error": "py-spy failed",
+                    "detail": msg,
+                    "hint": "Ensure the container has CAP_SYS_PTRACE / seccomp=unconfined",
+                },
+                status_code=500,
+            )
+
+        with open(path, "rb") as f:
+            content = f.read()
+        ts = int(time.time())
+        return Response(
+            content,
+            media_type="image/svg+xml",
+            headers={
+                "Content-Disposition": f"inline; filename=pyspy-{ts}.svg",
+                "Cache-Control": "no-store",
+            },
+        )
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(path)
+
+
+async def profile(request: ApiRequest):
+    if not config.FF_PYSPY_PROFILING_ENABLED:
+        return JSONResponse({"error": "Profiling disabled"}, status_code=403)
+
+    params = request.query_params
+    try:
+        seconds = _clamp_duration(int(params.get("seconds", "15")))
+    except ValueError:
+        return JSONResponse({"error": "Invalid seconds"}, status_code=400)
+    return await _profile_with_pyspy(seconds, "svg")
+
+
+profile_routes: list[BaseRoute] = [
+    ApiRoute("/profile", profile, methods=["GET"]),
+]

langgraph_api/api/runs.py

@@ -10,9 +10,24 @@ from starlette.responses import Response, StreamingResponse
 
 from langgraph_api import config
 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,
@@ -29,41 +44,56 @@ 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, 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:
-                thread = await anext(thread_iter)
-                if thread["status"] == "error":
-                    return orjson.dumps({"__error__": orjson.Fragment(thread["error"])})
-                if thread["status"] == "interrupted":
+                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:
-                        if isinstance(thread["interrupts"], dict):
-                            # Handle in memory format
-                            interrupt_map = thread["interrupts"]
-                        else:
-                            interrupt_map = orjson.loads(thread["interrupts"].buf)
+                        interrupt_map = json_loads(thread["interrupts"])
                         interrupt = [next(iter(interrupt_map.values()))[0]]
-                        return orjson.dumps({"__interrupt__": interrupt})
+                        return json_dumpb({"__interrupt__": interrupt})
                     except Exception:
                         # No interrupt, but status is interrupted from a before/after block. Default back to values.
                         pass
-                return cast(bytes, thread["values"])
+                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}",
@@ -96,10 +126,8 @@ def _run_result_body(
                 thread_id=thread_id,
                 ignore_404=ignore_404,
             ):
-                if (
-                    mode == b"values"
-                    or mode == b"updates"
-                    and b"__interrupt__" in chunk
+                if mode == b"values" or (
+                    mode == b"updates" and b"__interrupt__" in chunk
                 ):
                     vchunk = chunk
                 elif mode == b"error":
@@ -147,6 +175,7 @@ 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,
@@ -155,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']}"},
@@ -165,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,
@@ -173,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']}"},
@@ -197,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)
 
 
@@ -411,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,
@@ -421,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
@@ -435,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
@@ -519,14 +562,14 @@ 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",
     )
 
     sub = await Runs.Stream.subscribe(run_id, thread_id) if wait else None
     try:
         async with connect() as conn:
-            await Runs.cancel(
+            await CrudRuns.cancel(
                 conn,
                 [run_id],
                 action=action,
@@ -585,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,
@@ -609,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,
@@ -621,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")
 
@@ -670,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"):
@@ -692,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")
@@ -719,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",
@@ -746,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]