vercel-runtime 0.13.0__tar.gz → 0.13.2__tar.gz

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vercel-runtime
-Version: 0.13.0
+Version: 0.13.2
 License-Expression: Apache-2.0
 License-File: src/vercel_runtime/_vendor/__init__.py
 License-File: src/vercel_runtime/_vendor/click/LICENSE.txt

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vercel-runtime"
-version = "0.13.0"
+version = "0.13.2"
 license = "Apache-2.0"
 license-files = [
   "src/vercel_runtime/_vendor/*/LICEN[CS]E*",

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/src/vercel_runtime/crons.py

@@ -23,7 +23,13 @@ type CronHandler = SyncCronHandler | AsyncCronHandler
 
 def is_cron_service() -> bool:
     svc_type = os.environ.get("VERCEL_SERVICE_TYPE") or ""
-    return svc_type.strip().lower() == "cron"
+    normalized_type = svc_type.strip().lower()
+    if normalized_type == "cron":
+        return True
+
+    svc_trigger = os.environ.get("VERCEL_SERVICE_TRIGGER") or ""
+    normalized_trigger = svc_trigger.strip().lower()
+    return normalized_type == "job" and normalized_trigger == "schedule"
 
 
 def bootstrap_cron_service_app(module: ModuleType) -> ASGI:

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/src/vercel_runtime/dev.py

@@ -19,9 +19,9 @@ from vercel_runtime.routing import (
     strip_service_route_prefix,
 )
 from vercel_runtime.workers import (
-    bootstrap_worker_service_app,
     is_worker_service,
-    prepare_celery_environment,
+    maybe_bootstrap_worker_service_app,
+    prepare_worker_environment,
 )
 
 if TYPE_CHECKING:
@@ -397,7 +397,7 @@ def _setup_apps() -> None:
     variable_name = os.environ["VERCEL_DEV_VARIABLE_NAME"]
 
     _setup_server_log_routing()
-    prepare_celery_environment()
+    prepare_worker_environment()
 
     mod = import_module(module_name, entry_abs)
 
@@ -406,8 +406,10 @@ def _setup_apps() -> None:
         return
 
     if is_worker_service():
-        _asgi_user_app = cast("ASGI", bootstrap_worker_service_app(mod))
-        return
+        worker_app = maybe_bootstrap_worker_service_app(mod)
+        if worker_app is not None:
+            _asgi_user_app = cast("ASGI", worker_app)
+            return
 
     app_name, user_app = resolve_app(mod, module_name, variable_name)
     try:
@@ -432,7 +434,7 @@ def _wrap_django_static(app: WSGIApplication) -> WSGIApplication:
     # STATIC_URL are served from source directories via Django's staticfiles
     # finders, without needing collectstatic to have been run.
     try:
-        from django.conf import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+        from django.conf import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports, reportMissingTypeStubs]
             settings as django_settings,  # pyright: ignore[reportUnknownVariableType, reportMissingTypeStubs]
         )
 
@@ -464,10 +466,10 @@ def _handle_manifest(app: WSGIApplication) -> WSGIApplication | None:
     """
     import os  # noqa: PLC0415
 
-    from django import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+    from django import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports, reportMissingTypeStubs]
         VERSION as DJANGO_VERSION,  # pyright: ignore[reportUnknownVariableType]
     )
-    from django.conf import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+    from django.conf import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports, reportMissingTypeStubs]
         settings as django_settings,  # pyright: ignore[reportUnknownVariableType, reportMissingTypeStubs]
     )
     from django.utils.module_loading import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports, reportMissingTypeStubs]
@@ -520,7 +522,8 @@ def _handle_manifest(app: WSGIApplication) -> WSGIApplication | None:
 
     # Override the storage backend so {% static %} produces unhashed URLs
     plain = "django.contrib.staticfiles.storage.StaticFilesStorage"
-    if DJANGO_VERSION >= (5, 0):
+    django_major_version = cast("int", DJANGO_VERSION[0])
+    if django_major_version >= 5:
         storages = {**storages, "staticfiles": {"BACKEND": plain}}
         django_settings.STORAGES = storages  # pyright: ignore[reportAttributeAccessIssue]
     else:

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/src/vercel_runtime/headers.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
 import contextlib
+import os
 from collections.abc import Iterable, Mapping
 from importlib import import_module
 from typing import cast
 
+OIDC_HEADER_NAME = "x-vercel-oidc-token"
+INTERNAL_OIDC_HEADER_NAME = "x-vercel-internal-oidc-token"
+
 
 def _iter_header_items(headers: object) -> list[tuple[object, object]]:
     if isinstance(headers, Mapping):
@@ -47,14 +51,12 @@ def _iter_event_header_pairs(
 def _normalize_internal_oidc_header(
     headers: list[tuple[str, str]],
 ) -> list[tuple[str, str]]:
-    has_public_oidc = any(
-        key.lower() == "x-vercel-oidc-token" for key, _ in headers
-    )
+    has_public_oidc = any(key.lower() == OIDC_HEADER_NAME for key, _ in headers)
     internal_oidc_token = next(
         (
             value
             for key, value in headers
-            if key.lower() == "x-vercel-internal-oidc-token"
+            if key.lower() == INTERNAL_OIDC_HEADER_NAME
         ),
         None,
     )
@@ -62,15 +64,47 @@ def _normalize_internal_oidc_header(
     without_internal = [
         (key, value)
         for key, value in headers
-        if key.lower() != "x-vercel-internal-oidc-token"
+        if key.lower() != INTERNAL_OIDC_HEADER_NAME
     ]
 
-    if not has_public_oidc and internal_oidc_token is not None:
-        without_internal.append(("x-vercel-oidc-token", internal_oidc_token))
+    oidc_token = get_oidc_token_for_request(
+        has_public_oidc=has_public_oidc,
+        internal_oidc_token=internal_oidc_token,
+    )
+    if oidc_token:
+        without_internal.append((OIDC_HEADER_NAME, oidc_token))
 
     return without_internal
 
 
+def get_oidc_token_for_request(
+    *,
+    has_public_oidc: bool,
+    internal_oidc_token: str | None,
+) -> str | None:
+    if has_public_oidc:
+        return None
+    if internal_oidc_token:
+        return internal_oidc_token
+    return os.environ.get("VERCEL_OIDC_TOKEN") or None
+
+
+def append_oidc_header_if_missing(
+    headers_list: list[tuple[bytes, bytes]],
+    *,
+    internal_oidc_token: str | None,
+) -> None:
+    oidc_token = get_oidc_token_for_request(
+        has_public_oidc=any(
+            decode_header_bytes(k).lower() == OIDC_HEADER_NAME
+            for k, _ in headers_list
+        ),
+        internal_oidc_token=internal_oidc_token,
+    )
+    if oidc_token:
+        headers_list.append((OIDC_HEADER_NAME.encode(), oidc_token.encode()))
+
+
 def set_headers(headers: Mapping[str, str] | None) -> None:
     with contextlib.suppress(Exception):
         try:

{vercel_runtime-0.13.0 → vercel_runtime-0.13.2}/src/vercel_runtime/vc_init.py

@@ -23,8 +23,12 @@ from vercel_runtime.crons import (
     is_cron_service,
 )
 from vercel_runtime.headers import (
+    INTERNAL_OIDC_HEADER_NAME,
+    OIDC_HEADER_NAME,
+    append_oidc_header_if_missing,
     clear_vercel_headers_context,
     decode_header_bytes,
+    get_oidc_token_for_request,
     normalize_event_header_pairs,
     normalize_event_headers,
     set_vercel_headers_from_asgi_pairs,
@@ -41,10 +45,9 @@ from vercel_runtime.routing import (
     split_request_target,
 )
 from vercel_runtime.workers import (
-    bootstrap_worker_service_app,
-    is_celery_app,
     is_worker_service,
-    prepare_celery_environment,
+    maybe_bootstrap_worker_service_app,
+    prepare_worker_environment,
 )
 
 if TYPE_CHECKING:
@@ -467,31 +470,22 @@ if _extra_path:
     os.environ["PATH"] = _extra_path + ":" + os.environ.get("PATH", "")
 
 try:
-    prepare_celery_environment()
+    prepare_worker_environment()
     __vc_module = import_module(_entrypoint_modname, _entrypoint_abs)
     __vc_variables = dir(__vc_module)
 except Exception:
     _fatal_exc(f'could not import "{_entrypoint_rel}"')
 
 if is_worker_service():
-    if "handler" not in __vc_variables and "Handler" not in __vc_variables:
-        should_bootstrap_worker_app = (
-            "app" not in __vc_variables
-            or is_celery_app(getattr(__vc_module, "app", None))
-        )
-    else:
-        should_bootstrap_worker_app = False
-
-    if should_bootstrap_worker_app:
-        try:
-            __vc_module.__dict__["app"] = bootstrap_worker_service_app(
-                __vc_module
-            )
+    try:
+        worker_app = maybe_bootstrap_worker_service_app(__vc_module)
+        if worker_app is not None:
+            __vc_module.__dict__["app"] = worker_app
             __vc_variables = dir(__vc_module)
-        except Exception:
-            _stderr("Error bootstrapping worker service app:")
-            _stderr(traceback.format_exc())
-            exit(1)
+    except Exception:
+        _stderr("Error bootstrapping worker service app:")
+        _stderr(traceback.format_exc())
+        exit(1)
 
 if is_cron_service():
     try:
@@ -568,7 +562,7 @@ class ASGIMiddleware:
         new_headers: list[tuple[bytes, bytes]] = []
         invocation_id = "0"
         request_id = 0
-        internal_oidc_token = ""
+        internal_oidc_token: str | None = None
 
         for raw_k, raw_v in headers_list:
             key_bytes = raw_k if isinstance(raw_k, bytes) else raw_k.encode()
@@ -586,20 +580,15 @@ class ASGIMiddleware:
                 "x-vercel-internal-trace-id",
             ):
                 continue
-            if key == "x-vercel-internal-oidc-token":
+            if key == INTERNAL_OIDC_HEADER_NAME:
                 internal_oidc_token = val
                 continue
             new_headers.append((key_bytes, val_bytes))
 
-        if internal_oidc_token:
-            has_oidc_header = any(
-                decode_header_bytes(k).lower() == "x-vercel-oidc-token"
-                for k, _ in new_headers
-            )
-            if not has_oidc_header:
-                new_headers.append(
-                    (b"x-vercel-oidc-token", internal_oidc_token.encode())
-                )
+        append_oidc_header_if_missing(
+            new_headers,
+            internal_oidc_token=internal_oidc_token,
+        )
 
         new_scope = dict(scope)
         new_scope["headers"] = new_headers
@@ -748,17 +737,22 @@ if "VERCEL_IPC_PATH" in os.environ:
             del self.headers["x-vercel-internal-request-id"]
             del self.headers["x-vercel-internal-span-id"]
             del self.headers["x-vercel-internal-trace-id"]
-            internal_oidc_token = self.headers.get(
-                "x-vercel-internal-oidc-token"
+            raw_internal_oidc_token = self.headers.get(
+                INTERNAL_OIDC_HEADER_NAME
             )
-            if (
-                isinstance(internal_oidc_token, str)
-                and internal_oidc_token
-                and not self.headers.get("x-vercel-oidc-token")
-            ):
-                self.headers["x-vercel-oidc-token"] = internal_oidc_token
+            internal_oidc_token = (
+                raw_internal_oidc_token
+                if isinstance(raw_internal_oidc_token, str)
+                else None
+            )
+            oidc_token = get_oidc_token_for_request(
+                has_public_oidc=bool(self.headers.get(OIDC_HEADER_NAME)),
+                internal_oidc_token=internal_oidc_token,
+            )
+            if oidc_token:
+                self.headers[OIDC_HEADER_NAME] = oidc_token
             with contextlib.suppress(Exception):
-                del self.headers["x-vercel-internal-oidc-token"]
+                del self.headers[INTERNAL_OIDC_HEADER_NAME]
 
             send_message(
                 {

vercel_runtime-0.13.2/src/vercel_runtime/workers.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import contextlib
+import os
+from typing import Any, cast
+
+
+def is_worker_service() -> bool:
+    svc_type = os.environ.get("VERCEL_SERVICE_TYPE") or ""
+    normalized_type = svc_type.strip().lower()
+    if normalized_type == "worker":
+        return True
+
+    svc_trigger = os.environ.get("VERCEL_SERVICE_TRIGGER") or ""
+    normalized_trigger = svc_trigger.strip().lower()
+    return normalized_type == "job" and normalized_trigger == "queue"
+
+
+def has_worker_services() -> bool:
+    value = os.environ.get("VERCEL_HAS_WORKER_SERVICES") or ""
+    return value.strip().lower() in {"1", "true"}
+
+
+def _load_workers_runtime() -> Any | None:
+    with contextlib.suppress(ImportError):
+        import vercel.workers._runtime as workers_runtime  # type: ignore[import-not-found]  # noqa: PLC0415, PLC2701  # pyright: ignore[reportMissingImports]
+
+        return workers_runtime
+    return None
+
+
+def prepare_worker_environment() -> None:
+    workers_runtime = _load_workers_runtime()
+    if workers_runtime is None:
+        return
+    workers_runtime.prepare_environment(os.environ)
+
+
+def maybe_bootstrap_worker_service_app(module: object) -> object | None:
+    workers_runtime = _load_workers_runtime()
+    if workers_runtime is None:
+        raise RuntimeError(
+            "Unable to bootstrap worker service because "
+            '"vercel-workers" is missing. Install '
+            '"vercel-workers" and configure an explicit worker integration.'
+        )
+    return cast(
+        "object | None",
+        workers_runtime.maybe_bootstrap_worker_service_app(module),
+    )

vercel_runtime-0.13.0/src/vercel_runtime/workers.py

@@ -1,311 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import os
-from importlib import import_module
-from importlib.util import find_spec
-from typing import TYPE_CHECKING, cast
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Mapping
-
-
-def _has_module(module_name: str) -> bool:
-    try:
-        return find_spec(module_name) is not None
-    except ModuleNotFoundError:
-        return False
-
-
-def _import_optional_module(module_name: str) -> object | None:
-    with contextlib.suppress(Exception):
-        return import_module(module_name)
-    return None
-
-
-CELERY_AVAILABLE = _has_module("celery")
-DRAMATIQ_AVAILABLE = _has_module("dramatiq")
-DJANGO_TASKS_AVAILABLE = _has_module("django.tasks")
-VERCEL_WORKERS_AVAILABLE = _has_module("vercel.workers")
-
-VERCEL_CELERY_BROKER_URL = "vercel://"
-
-
-def is_worker_service() -> bool:
-    svc_type = os.environ.get("VERCEL_SERVICE_TYPE") or ""
-    return svc_type.strip().lower() == "worker"
-
-
-def has_worker_services() -> bool:
-    value = os.environ.get("VERCEL_HAS_WORKER_SERVICES") or ""
-    return value.strip().lower() in {"1", "true"}
-
-
-def _uses_vercel_celery_broker(broker_url: str | None) -> bool:
-    if broker_url is None:
-        return False
-    normalized = broker_url.strip().lower()
-    return normalized.startswith(VERCEL_CELERY_BROKER_URL)
-
-
-def _install_vercel_celery_transport_alias() -> None:
-    with contextlib.suppress(Exception):
-        transport_module = _import_optional_module(
-            "vercel.workers.celery.transport"
-        )
-        if transport_module is None:
-            return
-
-        install_transport_alias = getattr(
-            transport_module,
-            "install_kombu_transport_alias",
-            None,
-        )
-        if not callable(install_transport_alias):
-            return
-
-        install_transport_alias_fn = cast(
-            "Callable[[str], None]",
-            install_transport_alias,
-        )
-        install_transport_alias_fn("vercel")
-
-
-def prepare_celery_environment() -> None:
-    has_worker_svcs = has_worker_services()
-    if has_worker_svcs and "CELERY_BROKER_URL" not in os.environ:
-        os.environ["CELERY_BROKER_URL"] = VERCEL_CELERY_BROKER_URL
-
-    broker_url = os.environ.get("CELERY_BROKER_URL")
-    if not has_worker_svcs and not _uses_vercel_celery_broker(broker_url):
-        return
-
-    _install_vercel_celery_transport_alias()
-
-
-def is_celery_app(candidate: object) -> bool:
-    if candidate is None:
-        return False
-    module_name = getattr(candidate.__class__, "__module__", "")
-    if isinstance(module_name, str) and module_name.startswith("celery"):
-        return True
-    return (
-        hasattr(candidate, "conf")
-        and callable(getattr(candidate, "send_task", None))
-        and callable(getattr(candidate, "task", None))
-    )
-
-
-def _find_celery_app(module: object) -> object | None:
-    candidates = [
-        getattr(module, "app", None),
-        getattr(module, "celery_app", None),
-        getattr(module, "worker_app", None),
-        getattr(module, "worker", None),
-        getattr(module, "celery", None),
-    ]
-    for candidate in candidates:
-        if is_celery_app(candidate):
-            return candidate
-    return None
-
-
-def _bootstrap_dramatiq_worker_app(module: object) -> object | None:
-    if not DRAMATIQ_AVAILABLE:
-        return None
-
-    dramatiq_mod = _import_optional_module("dramatiq")
-    vercel_dramatiq = _import_optional_module("vercel.workers.dramatiq")
-    if dramatiq_mod is None or vercel_dramatiq is None:
-        if not VERCEL_WORKERS_AVAILABLE:
-            raise RuntimeError(
-                "Dramatiq worker service detected, but "
-                '"vercel-workers" is not installed. '
-                'Install "vercel-workers" and '
-                "configure "
-                '"from vercel.workers.dramatiq import '
-                'VercelQueuesBroker".'
-            )
-        raise RuntimeError(
-            "Failed to import Dramatiq worker adapter from vercel-workers."
-        )
-
-    broker_candidates: list[object] = []
-    module_broker = getattr(module, "broker", None)
-    if module_broker is not None:
-        broker_candidates.append(module_broker)
-    get_broker = getattr(dramatiq_mod, "get_broker", None)
-    if callable(get_broker):
-        with contextlib.suppress(Exception):
-            get_broker_fn = cast("Callable[[], object]", get_broker)
-            broker_candidates.append(get_broker_fn())
-
-    resolved_broker: object | None = None
-    broker_type = getattr(vercel_dramatiq, "VercelQueuesBroker", None)
-    if isinstance(broker_type, type):
-        for broker in broker_candidates:
-            if isinstance(broker, broker_type):
-                resolved_broker = broker
-                break
-
-    if resolved_broker is None:
-        return None
-
-    # Users must import task modules from the entrypoint.
-    actors = getattr(resolved_broker, "actors", None)
-    actors_mapping: Mapping[object, object] | None = None
-    if isinstance(actors, dict):
-        actors_mapping = cast("Mapping[object, object]", actors)
-    if actors_mapping is None or len(actors_mapping) == 0:
-        raise RuntimeError(
-            "Worker service did not register any Dramatiq "
-            "actors. Ensure your worker entrypoint imports "
-            "task modules before startup."
-        )
-
-    get_asgi_app = getattr(vercel_dramatiq, "get_asgi_app", None)
-    if not callable(get_asgi_app):
-        raise RuntimeError(
-            "Failed to resolve Dramatiq ASGI adapter from vercel-workers."
-        )
-    get_asgi_app_fn = cast(
-        "Callable[[object], object]",
-        get_asgi_app,
-    )
-    return get_asgi_app_fn(resolved_broker)
-
-
-def _bootstrap_celery_worker_app(module: object) -> object | None:
-    if not CELERY_AVAILABLE:
-        return None
-
-    celery_app = _find_celery_app(module)
-    if celery_app is None:
-        return None
-
-    vercel_celery = _import_optional_module("vercel.workers.celery")
-    if vercel_celery is None:
-        if not VERCEL_WORKERS_AVAILABLE:
-            raise RuntimeError(
-                'Celery worker service requires "vercel-workers". '
-                'Install "vercel-workers" and export a Celery app.'
-            )
-        raise RuntimeError(
-            "Failed to import Celery worker adapter from vercel-workers."
-        )
-
-    get_adapter_app = getattr(vercel_celery, "get_asgi_app", None)
-    if not callable(get_adapter_app):
-        raise RuntimeError(
-            "Failed to resolve Celery ASGI adapter from vercel-workers."
-        )
-    get_adapter_app_fn = cast(
-        "Callable[[object], object]",
-        get_adapter_app,
-    )
-    return get_adapter_app_fn(celery_app)
-
-
-def _bootstrap_django_worker_app(module: object) -> object | None:
-    if not DJANGO_TASKS_AVAILABLE:
-        return None
-
-    vercel_django = _import_optional_module("vercel.workers.django")
-    if vercel_django is None:
-        if not VERCEL_WORKERS_AVAILABLE:
-            raise RuntimeError(
-                "Django tasks worker service detected, but "
-                '"vercel-workers" is not installed. '
-                'Install "vercel-workers" and '
-                "configure "
-                '"vercel.workers.django.VercelQueuesBackend" '
-                "as your Django tasks backend."
-            )
-        raise RuntimeError(
-            "could not import Django tasks adapter from vercel-workers"
-        )
-
-    get_asgi_app = getattr(vercel_django, "get_asgi_app", None)
-    if not callable(get_asgi_app):
-        raise RuntimeError(
-            "could not resolve Django tasks ASGI adapter from vercel-workers"
-        )
-    get_asgi_app_fn = cast(
-        "Callable[[], object]",
-        get_asgi_app,
-    )
-    return get_asgi_app_fn()
-
-
-def _bootstrap_generic_worker_app() -> object | None:
-    if not VERCEL_WORKERS_AVAILABLE:
-        return None
-
-    vercel_workers = _import_optional_module("vercel.workers")
-    if vercel_workers is None:
-        return None
-
-    has_subscriptions = getattr(vercel_workers, "has_subscriptions", None)
-    get_asgi_app = getattr(vercel_workers, "get_asgi_app", None)
-    if not callable(has_subscriptions) or not callable(get_asgi_app):
-        return None
-
-    with contextlib.suppress(Exception):
-        has_subscriptions_fn = cast(
-            "Callable[[], bool]",
-            has_subscriptions,
-        )
-        if not has_subscriptions_fn():
-            return None
-
-        get_asgi_app_fn = cast(
-            "Callable[[], object]",
-            get_asgi_app,
-        )
-        return get_asgi_app_fn()
-
-    return None
-
-
-def bootstrap_worker_service_app(module: object) -> object:
-    if _find_celery_app(module) is not None:
-        try:
-            app = _bootstrap_celery_worker_app(module)
-            if app is not None:
-                return app
-        except Exception as exc:
-            raise RuntimeError("Celery worker bootstrap failed.") from exc
-
-    if DRAMATIQ_AVAILABLE:
-        try:
-            app = _bootstrap_dramatiq_worker_app(module)
-            if app is not None:
-                return app
-        except Exception as exc:
-            raise RuntimeError("Dramatiq worker bootstrap failed.") from exc
-
-    if DJANGO_TASKS_AVAILABLE:
-        try:
-            app = _bootstrap_django_worker_app(module)
-            if app is not None:
-                return app
-        except Exception as exc:
-            raise RuntimeError("Django tasks worker bootstrap failed.") from exc
-
-    app = _bootstrap_generic_worker_app()
-    if app is not None:
-        return app
-
-    if not VERCEL_WORKERS_AVAILABLE:
-        raise RuntimeError(
-            "Unable to bootstrap worker service because "
-            '"vercel-workers" is missing. Install '
-            '"vercel-workers" and configure an '
-            "explicit worker integration."
-        )
-
-    raise RuntimeError(
-        "Unable to bootstrap worker service. "
-        "Export an ASGI/WSGI app, or configure "
-        "Celery/Dramatiq/Django via vercel-workers."
-    )