prefect-client 3.8.1.dev5__tar.gz → 3.8.2__tar.gz

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.8.1.dev5
+Version: 3.8.2
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: <3.15,>=3.10
 Requires-Dist: amplitude-analytics<2.0.0,>=1.2.1
-Requires-Dist: anyio!=4.14.2,<5.0.0,>=4.4.0
+Requires-Dist: anyio<5.0.0,>=4.4.0
 Requires-Dist: asgi-lifespan<3.0,>=1.0
 Requires-Dist: cachetools<8.0,>=5.3
 Requires-Dist: cloudpickle<4.0,>=2.0

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/pyproject.toml

@@ -26,7 +26,7 @@ classifiers = [
 dependencies = [
     # Client dependencies
     "amplitude-analytics>=1.2.1,<2.0.0",
-    "anyio>=4.4.0,<5.0.0,!=4.14.2",
+    "anyio>=4.4.0,<5.0.0",
     "asgi-lifespan>=1.0,<3.0",
     "cachetools>=5.3,<8.0",
     "cloudpickle>=2.0,<4.0",

prefect_client-3.8.2/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.2"
+__build_date__ = "2026-08-07 21:16:33.823431+00:00"
+__git_commit__ = "b535a27ea1b567bd0363b94617fc2502a56d23c8"
+__dirty__ = False

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/_internal/concurrency/services.py

@@ -408,10 +408,21 @@ class FutureQueueService(
             # If the request to the increment endpoint fails in a non-standard
             # way, we need to set the future's result so it'll be re-raised in
             # the context of the caller.
-            future.set_exception(exc)
+            if future.set_running_or_notify_cancel():
+                future.set_exception(exc)
             raise exc
         else:
-            future.set_result(response)
+            # Transitioning the future to running before setting its result closes
+            # the window where the caller cancels it while `acquire` is in flight:
+            # after this point `cancel()` fails, and if the caller got there first
+            # the acquired resource is nobody's and must be discarded.
+            if future.set_running_or_notify_cancel():
+                future.set_result(response)
+            else:
+                await self._discard(response)
+
+    async def _discard(self, response: R) -> None:
+        """Dispose of a result whose caller is no longer waiting for it."""
 
     @abc.abstractmethod
     async def acquire(self, *args: Unpack[Ts]) -> R:

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/_internal/control_listener.py

@@ -13,7 +13,7 @@ Protocol:
    one-shot env vars without connecting yet.
 3. The outermost `capture_sigterm()` calls `start()`, which connects back to
    the runner and spawns a daemon thread blocked on the socket.
-4. The runner writes a single-byte intent (`b"c"` today).
+4. The runner writes a single-byte intent (`b"c"`, `b"r"` or `b"q"`).
 5. If Prefect still owns the live SIGTERM bridge, the child writes `b"a"`,
    commits the intent for engine dispatch, and on Windows triggers
    `_thread.interrupt_main(SIGTERM)`.
@@ -37,10 +37,12 @@ from typing import Literal
 
 from prefect.utilities.engine import commit_control_intent_and_ack
 
-Intent = Literal["cancel"]
+Intent = Literal["cancel", "reschedule", "relinquish"]
 
 _INTENT_FOR_BYTE: dict[bytes, Intent] = {
     b"c": "cancel",
+    b"r": "reschedule",
+    b"q": "relinquish",
 }
 
 _intent: Intent | None = None

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/_internal/websockets.py

@@ -14,6 +14,8 @@ from urllib.parse import urlparse
 import certifi
 from websockets.asyncio.client import connect
 
+import prefect
+from prefect.client.constants import SERVER_API_VERSION
 from prefect.settings import get_current_settings
 
 
@@ -51,6 +53,13 @@ def websocket_connect(uri: str, **kwargs: Any) -> connect:
     if ssl_context:
         kwargs.setdefault("ssl", ssl_context)
 
+    # Identify ourselves to the server the same way the HTTP client does so that
+    # the client version can be parsed from the handshake
+    kwargs.setdefault(
+        "user_agent_header",
+        f"prefect/{prefect.__version__} (API {SERVER_API_VERSION})",
+    )
+
     # Add custom headers from settings
     custom_headers = get_current_settings().client.custom_headers
     if custom_headers:

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/blocks/core.py

@@ -424,6 +424,14 @@ class Block(BaseModel, ABC):
     def ser_model(
         self, handler: SerializerFunctionWrapHandler, info: SerializationInfo
     ) -> Any:
+        if info.context and info.context.get("serialize_blocks_as_references"):
+            if self._block_document_id is None:
+                raise BlockNotSavedError(
+                    "Block must be saved with `.save()` before it can be used as a "
+                    "deployment parameter."
+                )
+            return {"$ref": {"block_document_id": str(self._block_document_id)}}
+
         jsonable_self = handler(self)
         if (ctx := info.context) and ctx.get("include_secrets") is True:
             # Add serialization mode to context so handle_secret_render knows how to process nested models

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/client/orchestration/_work_pools/client.py

@@ -48,7 +48,7 @@ class WorkPoolClient(BaseClient):
         Args:
             work_pool_name: The name of the work pool to heartbeat against.
             worker_name: The name of the worker sending the heartbeat.
-            return_id: Whether to return the worker ID. Note: will return `None` if the connected server does not support returning worker IDs, even if `return_id` is `True`.
+            get_worker_id: Whether to return the worker ID. Note: will return `None` if the connected server does not support returning worker IDs, even if `get_worker_id` is `True`.
             worker_metadata: Metadata about the worker to send to the server.
         """
         from uuid import UUID
@@ -376,7 +376,7 @@ class WorkPoolAsyncClient(BaseAsyncClient):
         Args:
             work_pool_name: The name of the work pool to heartbeat against.
             worker_name: The name of the worker sending the heartbeat.
-            return_id: Whether to return the worker ID. Note: will return `None` if the connected server does not support returning worker IDs, even if `return_id` is `True`.
+            get_worker_id: Whether to return the worker ID. Note: will return `None` if the connected server does not support returning worker IDs, even if `get_worker_id` is `True`.
             worker_metadata: Metadata about the worker to send to the server.
         """
         from uuid import UUID

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/client/schemas/objects.py

@@ -1477,7 +1477,7 @@ class WorkQueueHealthPolicy(PrefectBaseModel):
         Given empirical information about the state of the work queue, evaluate its health status.
 
         Args:
-            late_runs: the count of late runs for the work queue.
+            late_runs_count: the count of late runs for the work queue.
             last_polled: the last time the work queue was polled, if available.
 
         Returns:

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/concurrency/_asyncio.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import logging
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, AsyncGenerator, Literal, Optional
@@ -150,6 +151,9 @@ async def aacquire_concurrency_slots_with_lease(
     )
     try:
         response = await asyncio.wrap_future(future)
+    except asyncio.CancelledError:
+        _release_lease_when_granted(service, future)
+        raise
     except TimeoutError as timeout:
         raise AcquireConcurrencySlotTimeoutError(
             f"Attempt to acquire concurrency slots timed out after {timeout_seconds} second(s)"
@@ -225,6 +229,28 @@ def _discard_cleanup_lease(lease_id: UUID) -> None:
         ctx.cleanup_lease_ids.remove(lease_id)
 
 
+def _release_lease_when_granted(
+    service: ConcurrencySlotAcquisitionWithLeaseService,
+    future: "concurrent.futures.Future[httpx.Response]",
+) -> None:
+    """Release the lease for an acquisition whose caller has been cancelled.
+
+    The acquisition may still be granted after the caller is gone, and the lease
+    id never reaches the `ConcurrencyContext`, so the slots would stay occupied
+    until the lease expires. The cancelled caller cannot do the release itself, so
+    the service that acquired the slots is asked to release them.
+    """
+
+    def _release(completed: "concurrent.futures.Future[httpx.Response]") -> None:
+        if completed.cancelled() or completed.exception() is not None:
+            # Nothing was granted, so there is nothing to release.
+            return
+
+        service.release_orphaned_lease(completed.result())
+
+    future.add_done_callback(_release)
+
+
 def _response_to_minimal_concurrency_limit_response(
     response: httpx.Response,
 ) -> list[MinimalConcurrencyLimitResponse]:

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/concurrency/services.py

@@ -1,10 +1,11 @@
 import asyncio
+import concurrent.futures
 import json
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from threading import Lock
 from typing import TYPE_CHECKING, Literal, Optional
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 import cachetools
 import httpx
@@ -104,12 +105,25 @@ class ConcurrencySlotAcquisitionWithLeaseService(
         super().__init__(concurrency_limit_names)
         self._client: PrefectClient
         self.concurrency_limit_names: list[str] = sorted(list(concurrency_limit_names))
+        self._pending_releases: set[concurrent.futures.Future[None]] = set()
 
     @asynccontextmanager
     async def _lifespan(self) -> AsyncGenerator[None, None]:
         async with get_client() as client:
             self._client = client
-            yield
+            try:
+                yield
+            finally:
+                # The client closes when this exits, so releases scheduled by
+                # cancelled callers have to finish first or their slots leak.
+                if self._pending_releases:
+                    await asyncio.gather(
+                        *(
+                            asyncio.wrap_future(release)
+                            for release in tuple(self._pending_releases)
+                        ),
+                        return_exceptions=True,
+                    )
 
     async def acquire(
         self,
@@ -185,6 +199,74 @@ class ConcurrencySlotAcquisitionWithLeaseService(
                     if max_retries is not None:
                         max_retries -= 1
 
+    async def _discard(self, response: httpx.Response) -> None:
+        """Release a lease granted to a caller that was cancelled while waiting.
+
+        Without this the slots stay occupied until the lease expires, because the
+        caller never learns the lease id and so cannot record it for cleanup.
+        """
+        lease_id = self._lease_id_from_response(response)
+        if lease_id is None:
+            return
+
+        try:
+            await self._client.release_concurrency_slots_with_lease(lease_id=lease_id)
+        except Exception:
+            logger.warning(
+                f"Failed to release concurrency lease {lease_id} for "
+                f"{self.concurrency_limit_names} after the acquiring caller was cancelled",
+                exc_info=True,
+            )
+
+    def release_orphaned_lease(
+        self, response: httpx.Response
+    ) -> "concurrent.futures.Future[None]":
+        """Release a lease that was delivered to a caller which is already gone.
+
+        The release is scheduled on the service's own loop so it reuses the client
+        that acquired the slots, keeping acquisition and cleanup on the same API, and
+        is tracked so that draining the service waits for it.
+        """
+        with self._lock:
+            loop = self._loop
+            if self._stopped or loop is None or loop.is_closed():
+                logger.warning(
+                    f"Unable to release concurrency lease for {self.concurrency_limit_names} "
+                    "after the acquiring caller was cancelled: the acquisition service is "
+                    "no longer running. The slots remain occupied until the lease expires."
+                )
+                stopped: concurrent.futures.Future[None] = concurrent.futures.Future()
+                stopped.set_result(None)
+                return stopped
+
+            # Registering under the lock `_stop` uses keeps the service from
+            # finishing its lifespan, and closing its client, before this release.
+            release = asyncio.run_coroutine_threadsafe(self._discard(response), loop)
+            self._pending_releases.add(release)
+
+        release.add_done_callback(self._pending_releases.discard)
+        return release
+
+    def _lease_id_from_response(self, response: httpx.Response) -> Optional[UUID]:
+        """Read the lease id out of a successful acquisition response.
+
+        Returns `None` when no slots were acquired, and logs when the response is
+        malformed, since that leaves a possibly active lease we cannot release.
+        """
+        try:
+            data = response.json()
+            if not data.get("limits"):
+                return None
+            return UUID(data["lease_id"])
+        except Exception:
+            logger.warning(
+                f"Unable to read the lease id from the acquisition response for "
+                f"{self.concurrency_limit_names}; if a lease was granted its slots "
+                "remain occupied until it expires.",
+                exc_info=True,
+            )
+            return None
+
 
 def _should_use_cache(
     names: list[str], holder: Optional["ConcurrencyLeaseHolder"]

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/context.py

@@ -14,6 +14,7 @@ import warnings
 from collections.abc import AsyncGenerator, Generator, Mapping
 from contextlib import ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar, Token
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -46,11 +47,13 @@ from prefect.results import (
 )
 from prefect.settings import Profile, Settings
 from prefect.settings.legacy import (
+    Setting,
     _get_settings_fields,  # type: ignore[reportPrivateUsage]
 )
 from prefect.states import State
 from prefect.task_runners import TaskRunner
 from prefect.types import DateTime
+from prefect.utilities.collections import visit_collection
 from prefect.utilities.services import start_client_metrics_server
 
 T = TypeVar("T")
@@ -825,6 +828,21 @@ class SettingsContext(ContextModel):
     def __hash__(self: Self) -> int:
         return hash(self.settings)
 
+    def serialize(self, include_secrets: bool = True) -> dict[str, Any]:
+        """Serialize settings without platform-specific path objects."""
+        serialized = super().serialize(include_secrets=include_secrets)
+        return visit_collection(
+            serialized,
+            visit_fn=lambda value: (
+                value.name
+                if isinstance(value, Setting)
+                else str(value)
+                if isinstance(value, Path)
+                else value
+            ),
+            return_data=True,
+        )
+
     @classmethod
     def get(cls) -> Optional["SettingsContext"]:
         # Return the global context instead of `None` if no context exists
@@ -976,7 +994,7 @@ def use_profile(
 
     Args:
         profile: The name of the profile to load or an instance of a Profile.
-        override_environment_variable: If set, variables in the profile will take
+        override_environment_variables: If set, variables in the profile will take
             precedence over current environment variables. By default, environment
             variables will override profile settings.
         include_current_context: If set, the new settings will be constructed

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/deployments/runner.py

@@ -53,6 +53,8 @@ from pydantic import (
     ConfigDict,
     Field,
     PrivateAttr,
+    TypeAdapter,
+    field_serializer,
     field_validator,
     model_validator,
 )
@@ -69,6 +71,7 @@ from prefect._internal.schemas.validators import (
     reconcile_schedules_runner,
 )
 from prefect._internal.versioning import VersionType, get_inferred_version_info
+from prefect.blocks.core import Block, BlockNotSavedError
 from prefect.client.base import ServerType
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas.actions import (
@@ -106,7 +109,12 @@ from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.annotations import freeze
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.callables import ParameterSchema, parameter_schema
-from prefect.utilities.collections import get_from_dict, isiterable
+from prefect.utilities.collections import (
+    StopVisiting,
+    get_from_dict,
+    isiterable,
+    visit_collection,
+)
 from prefect.utilities.dockerutils import (
     parse_image_tag,
 )
@@ -117,6 +125,11 @@ if TYPE_CHECKING:
 
 __all__ = ["RunnerDeployment"]
 
+_DEPLOYMENT_PARAMETER_SERIALIZER = TypeAdapter(
+    dict[str, Any],
+    config=ConfigDict(ser_json_timedelta="float"),
+)
+
 
 def _extract_concurrency_options(
     concurrency_limit: Union[int, ConcurrencyLimitConfig, None],
@@ -296,6 +309,47 @@ class RunnerDeployment(BaseModel):
     def full_name(self) -> str:
         return f"{self.flow_name}/{self.name}"
 
+    @field_validator("parameters", "schedules", mode="before")
+    @classmethod
+    def validate_block_parameters(cls, value: Any) -> Any:
+        def ensure_block_is_saved(value: Any) -> Any:
+            if isinstance(value, Block):
+                if value._block_document_id is None:
+                    raise BlockNotSavedError(
+                        "Block must be saved with `.save()` before it can be used as a "
+                        "deployment parameter."
+                    )
+                raise StopVisiting()
+            return value
+
+        visit_collection(value, ensure_block_is_saved)
+        return value
+
+    @field_serializer("parameters", when_used="json")
+    def serialize_block_parameters(self, parameters: dict[str, Any]) -> dict[str, Any]:
+        return _DEPLOYMENT_PARAMETER_SERIALIZER.dump_python(
+            parameters,
+            mode="json",
+            context={"serialize_blocks_as_references": True},
+        )
+
+    def _schedules_with_serialized_block_parameters(
+        self,
+    ) -> Optional[List[Union[DeploymentScheduleCreate, DeploymentScheduleUpdate]]]:
+        if self.schedules is None:
+            return None
+
+        return [
+            schedule.model_copy(
+                update={
+                    "parameters": self.serialize_block_parameters(schedule.parameters)
+                }
+            )
+            if schedule.parameters
+            else schedule
+            for schedule in self.schedules
+        ]
+
     def _get_deployment_version_info(
         self, version_type: Optional[VersionType] = None
     ) -> VersionInfo:
@@ -378,6 +432,9 @@ class RunnerDeployment(BaseModel):
                 " with a work pool."
             )
 
+        parameters = self.model_dump(mode="json", include={"parameters"})["parameters"]
+        schedules = self._schedules_with_serialized_block_parameters()
+
         async with get_client() as client:
             flow_id = await client.create_flow_from_name(self.flow_name)
 
@@ -389,10 +446,10 @@ class RunnerDeployment(BaseModel):
                 version=self.version,
                 version_info=version_info,
                 paused=self.paused,
-                schedules=self.schedules,
+                schedules=schedules,
                 concurrency_limit=self.concurrency_limit,
                 concurrency_options=self.concurrency_options,
-                parameters=self.parameters,
+                parameters=parameters,
                 description=self.description,
                 tags=self.tags,
                 path=self._path,
@@ -481,6 +538,9 @@ class RunnerDeployment(BaseModel):
                 " with a work pool."
             )
 
+        parameters = self.model_dump(mode="json", include={"parameters"})["parameters"]
+        schedules = self._schedules_with_serialized_block_parameters()
+
         with get_client(sync_client=True) as client:
             flow_id = client.create_flow_from_name(self.flow_name)
 
@@ -492,10 +552,10 @@ class RunnerDeployment(BaseModel):
                 version=self.version,
                 version_info=version_info,
                 paused=self.paused,
-                schedules=self.schedules,
+                schedules=schedules,
                 concurrency_limit=self.concurrency_limit,
                 concurrency_options=self.concurrency_options,
-                parameters=self.parameters,
+                parameters=parameters,
                 description=self.description,
                 tags=self.tags,
                 path=self._path,
@@ -579,7 +639,7 @@ class RunnerDeployment(BaseModel):
         if self.schedules:
             update_payload["schedules"] = [
                 schedule.model_dump(mode="json", exclude_unset=True)
-                for schedule in self.schedules
+                for schedule in self._schedules_with_serialized_block_parameters() or []
             ]
 
         await client.update_deployment(
@@ -631,7 +691,7 @@ class RunnerDeployment(BaseModel):
         if self.schedules:
             update_payload["schedules"] = [
                 schedule.model_dump(mode="json", exclude_unset=True)
-                for schedule in self.schedules
+                for schedule in self._schedules_with_serialized_block_parameters() or []
             ]
 
         client.update_deployment(

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/engine.py

@@ -100,16 +100,14 @@ def handle_engine_signals(flow_run_id: UUID | None = None):
         engine_logger.info(msg)
         exit(0)
     except TerminationSignal:
-        # A TerminationSignal can mean either:
-        # - an expected runner-driven control action (today: cancel intent),
-        # - or a raw external termination with no runner intent attached.
-        #
-        # Only the first case should translate to a clean process exit.
-        if get_intent() == "cancel":
+        # An intent means the runner or the `prefect flow-run execute` supervisor
+        # drove this termination and owns the flow run's next state, so exit cleanly.
+        # A raw external termination has no intent and must keep propagating.
+        if get_intent() is not None:
             if flow_run_id:
-                msg = f"Execution of flow run '{flow_run_id}' was cancelled."
+                msg = f"Execution of flow run '{flow_run_id}' was terminated."
             else:
-                msg = "Execution was cancelled."
+                msg = "Execution was terminated."
             engine_logger.info(msg)
             clear_intent()
             exit(0)

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/events/clients.py

@@ -718,7 +718,6 @@ class PrefectEventSubscriber:
         """
         Args:
             api_url: The base URL for a Prefect Cloud workspace
-            api_key: The API of an actor with the manage_events scope
             reconnection_attempts: When the client is disconnected, how many times
                 the client should attempt to reconnect
             reconnect_on_clean_close: Whether to reconnect when the server closes

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/events/utilities.py

@@ -49,9 +49,13 @@ def emit_event(
         payload: An open-ended set of data describing what happened.
         id: The sender-provided identifier for this event. Defaults to a random
             UUID.
-        follows: The event that preceded this one. If the preceding event
-            happened more than 5 minutes prior to this event the follows
-            relationship will not be set.
+        follows: The event that preceded this one. Setting `follows`
+            establishes that this event is known to have occurred after the
+            given event, which the system can use to disambiguate the
+            ordering of the two events. Only the `id` and `occurred` of the
+            given event are used; it is not emitted again. If the preceding
+            event happened more than 5 minutes prior to this event the
+            follows relationship will not be set.
 
     Returns:
         The event that was emitted if worker is using a client that emit

{prefect_client-3.8.1.dev5 → prefect_client-3.8.2}/src/prefect/flow_engine.py

@@ -195,26 +195,17 @@ def _termination_intent() -> Intent | None:
     for the outermost flow run as well as nested subflows running in the
     same process.
 
-    Today the only non-None value returned is `"cancel"`. A follow-up PR
-    will add `"suspend"` by extending
-    `Intent` in `prefect._internal.control_listener`; the engine's
-    `except TerminationSignal` dispatch below will gain a matching branch.
+    Adding an intent means extending `Intent` in
+    `prefect._internal.control_listener` and the `except TerminationSignal`
+    dispatch below with a matching branch.
     """
     return get_intent()
 
 
-def _should_bubble_raw_sigterm_for_reschedule() -> bool:
-    """Return whether raw SIGTERM should bypass crash handling.
-
-    `prefect flow-run execute` supports a reschedule mode where the parent
-    process proposes `AwaitingRetry` and then sends a plain SIGTERM to the
-    child. That path does not use the control channel, so the child must not
-    reinterpret the resulting `TerminationSignal` as a crash.
-    """
-    return (
-        os.environ.get("PREFECT_FLOW_RUN_EXECUTE_SIGTERM_BEHAVIOR", "").lower()
-        == "reschedule"
-    )
+# Intents where the `prefect flow-run execute` supervisor owns the run's next state
+# (`reschedule` proposes it; `relinquish` leaves it to retrying infrastructure), so
+# the engine must exit without proposing one.
+_SUPERVISOR_OWNED_INTENTS: frozenset[Intent] = frozenset({"reschedule", "relinquish"})
 
 
 def _is_async_runtime_cancellation(exc: BaseException) -> bool:
@@ -1198,10 +1189,8 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                     if intent == "cancel":
                         self.handle_cancellation(exc)
                     elif intent is None:
-                        if _should_bubble_raw_sigterm_for_reschedule():
-                            raise
                         self.handle_crash(exc)
-                    else:
+                    elif intent not in _SUPERVISOR_OWNED_INTENTS:
                         # Defensive: an unknown intent means the control
                         # listener was extended (e.g. "suspend" in a
                         # follow-up PR) without extending this dispatch.
@@ -1896,10 +1885,8 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                     if intent == "cancel":
                         await self.handle_cancellation(exc)
                     elif intent is None:
-                        if _should_bubble_raw_sigterm_for_reschedule():
-                            raise
                         await self.handle_crash(exc)
-                    else:
+                    elif intent not in _SUPERVISOR_OWNED_INTENTS:
                         # Defensive: see sync engine's dispatch for why.
                         self.logger.error(
                             "Unhandled termination intent %r; treating as"
@@ -1936,6 +1923,13 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                                 exc_info=exc,
                             )
                             raise
+                    if (
+                        _is_async_runtime_cancellation(exc)
+                        and _termination_intent() in _SUPERVISOR_OWNED_INTENTS
+                    ):
+                        # A supervisor-driven SIGTERM can surface here as a cancellation
+                        # rather than a TerminationSignal.
+                        raise TerminationSignal(signal.SIGTERM) from exc
                     # We don't want to crash a flow run if the user code finished executing
                     if self.flow_run.state and not self.flow_run.state.is_final():
                         # BaseExceptions are caught and handled as crashes