durable-workflow 2.5.1__tar.gz → 2.5.3__tar.gz

{durable_workflow-2.5.1/src/durable_workflow.egg-info → durable_workflow-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.1
+Version: 2.5.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.1"
+version = "2.5.3"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,8 +71,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.1"
-registry-version = "2.5.1"
+product-train = "2.5.3"
+registry-version = "2.5.3"
 supported-server-versions = "2.5.16"
 worker-protocol-version = "1.19"
 control-plane-version = "2"

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow/__init__.py

@@ -81,6 +81,7 @@ from .errors import (
     ExternalPayloadUnavailable,
     ExternalPayloadUnsupported,
     InvalidArgument,
+    InvalidWorkflowDefinition,
     NamespaceNotFound,
     NexusOperationFailed,
     NonDeterministicReplayError,
@@ -369,6 +370,7 @@ __all__ = [
     "NexusOperationResult",
     "NexusServiceCall",
     "NonDeterministicReplayError",
+    "InvalidWorkflowDefinition",
     "NoopMetrics",
     "QueryFailed",
     "RuntimeCapabilityUnsupported",

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow/errors.py

@@ -27,6 +27,10 @@ class DurableWorkflowError(Exception):
     """Base class for every exception raised by the SDK."""
 
 
+class InvalidWorkflowDefinition(DurableWorkflowError, ValueError):
+    """Workflow authoring uses an unsupported entry point or result."""
+
+
 class DurableOperationCancelled(DurableWorkflowError):
     """A durable selection member was explicitly cancelled."""
 

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow/testing.py

@@ -51,6 +51,7 @@ from .workflow import (
     StartChildWorkflow,
     StartTimer,
     UpsertSearchAttributes,
+    _validate_workflow_entrypoint,
     registry,
     replay,
 )
@@ -134,6 +135,7 @@ class WorkflowEnvironment:
                 f"{workflow_cls!r} is not a workflow class; "
                 "decorate it with @workflow.defn(name=...) first."
             )
+        _validate_workflow_entrypoint(workflow_cls)
         self._registered_workflows[name] = workflow_cls
 
     def signal(

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow/worker.py

@@ -69,6 +69,7 @@ from .errors import (
     DurableWorkflowError,
     ExternalPayloadError,
     InvalidArgument,
+    NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
     ServerError,
@@ -104,6 +105,7 @@ from .workflow import (
     ScheduleActivity,
     StartChildWorkflow,
     UpsertMemo,
+    _validate_workflow_entrypoint,
     apply_update,
     commands_to_server_commands,
     query_state,
@@ -1023,7 +1025,10 @@ class Worker:
     ) -> None:
         self.client = client
         self.task_queue = task_queue
-        self.workflows = {_workflow_name(w): w for w in workflows}
+        self.workflows: dict[str, type] = {}
+        for definition in workflows:
+            _validate_workflow_entrypoint(definition)
+            self.workflows[_workflow_name(definition)] = definition
         self.workflow_definition_fingerprints = {
             workflow_type: _workflow_definition_fingerprint(workflow_cls)
             for workflow_type, workflow_cls in self.workflows.items()
@@ -2498,20 +2503,35 @@ class Worker:
 
         update_id = task.get("workflow_update_id")
         if isinstance(update_id, str) and update_id:
-            update_command = apply_update(
-                cls,
-                history,
-                start_input,
-                update_id,
-                workflow_id=task.get("workflow_id"),
-                run_id=run_id,
-                payload_codec=codec,
-                external_storage=self.external_storage,
-                external_storage_cache=self.external_storage_cache,
-                prepare_local_activities=self._prepared_local_activities_supported,
-                prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
-                local_activity_cancellation_policies=self._local_activity_cancellation_policies,
-            )
+            try:
+                update_command = apply_update(
+                    cls,
+                    history,
+                    start_input,
+                    update_id,
+                    workflow_id=task.get("workflow_id"),
+                    run_id=run_id,
+                    payload_codec=codec,
+                    external_storage=self.external_storage,
+                    external_storage_cache=self.external_storage_cache,
+                    prepare_local_activities=self._prepared_local_activities_supported,
+                    prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
+                    local_activity_cancellation_policies=self._local_activity_cancellation_policies,
+                )
+            except NonDeterministicReplayError as exc:
+                log.exception("workflow update task %s replay failed for run %s", task_id, run_id)
+                try:
+                    await self.client.fail_workflow_task(
+                        task_id=task_id,
+                        lease_owner=self.worker_id,
+                        workflow_task_attempt=attempt,
+                        message=f"workflow replay failed before update {update_id!r}: {exc}",
+                        failure_type=type(exc).__name__,
+                        stack_trace=traceback.format_exc(),
+                    )
+                except Exception as failure_error:
+                    log.warning("failed to report update replay failure: %s", failure_error)
+                return None
             command = update_command.to_server_command(
                 self.task_queue,
                 payload_codec=command_codec,

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow/workflow.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import base64
 import contextlib
 import hashlib
+import inspect
 import logging
 import math
 import random
@@ -58,6 +59,7 @@ from .errors import (
     ChildWorkflowFailed,
     ChildWorkflowTerminated,
     DurableOperationCancelled,
+    InvalidWorkflowDefinition,
     NexusOperationFailed,
     NonDeterministicReplayError,
     QueryFailed,
@@ -97,6 +99,31 @@ MESSAGE_STREAM_CURSOR_SCHEMA = "durable-workflow.v2.message-stream.cursor"
 MESSAGE_STREAM_MAX_BATCH = 100
 
 
+def _validate_workflow_entrypoint(cls: type) -> None:
+    entrypoint = getattr(cls, "run", None)
+    if not callable(entrypoint):
+        return
+    targets = [inspect.unwrap(entrypoint)]
+    if not inspect.isroutine(targets[0]):
+        targets.append(inspect.unwrap(targets[0].__call__))
+    if any(inspect.iscoroutinefunction(target) or inspect.isasyncgenfunction(target) for target in targets):
+        name = getattr(cls, "__workflow_name__", cls.__name__)
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_entrypoint: workflow {name!r} ({cls.__qualname__}.run) "
+            "must use a synchronous function or generator; yield durable commands instead of async def."
+        )
+
+
+def _validate_workflow_result(value: Any, cls: type) -> None:
+    if inspect.isawaitable(value) or inspect.isasyncgen(value):
+        if inspect.iscoroutine(value):
+            value.close()
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_result: {cls.__qualname__}.run returned an async value; "
+            "use a synchronous result or yield durable commands."
+        )
+
+
 def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     """Register a class as a workflow type under a language-neutral name.
 
@@ -108,6 +135,7 @@ def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
 
     def wrap(cls: type[_WorkflowT]) -> type[_WorkflowT]:
         cls.__workflow_name__ = name  # type: ignore[attr-defined]
+        _validate_workflow_entrypoint(cls)
         signals: dict[str, str] = {}
         queries: dict[str, str] = {}
         updates: dict[str, str] = {}
@@ -3039,6 +3067,8 @@ def apply_update(
             prepare_local_activity_groups=prepare_local_activity_groups,
             local_activity_cancellation_policies=local_activity_cancellation_policies,
         )
+    except NonDeterministicReplayError:
+        raise
     except Exception as exc:
         return _fail_update_from_exception(
             update_id,
@@ -4037,6 +4067,7 @@ def _replay_state(
     allow_cancellation_scope_authoring: bool = False,
     allow_cancellation_scope_delivery: bool = False,
 ) -> _ReplayState:
+    _validate_workflow_entrypoint(workflow_cls)
     if allow_cancellation_scope_delivery and not allow_cancellation_scope_authoring:
         raise LocalActivityExecutionAborted("scope delivery requires canonical scope authoring")
     if prepare_local_activity_groups and not prepare_local_activities:
@@ -5115,16 +5146,20 @@ def _replay_state(
         for _ in range(boundary):
             _apply_receiver(pending_receivers.pop(0))
 
-    def _condition_wait_mismatch(opened: Mapping[str, Any], cmd: WaitCondition) -> FailWorkflow | None:
+    def _condition_wait_mismatch(
+        opened: Mapping[str, Any], cmd: WaitCondition,
+    ) -> NonDeterministicReplayError | None:
+        step = recorded_wait_steps[wait_yield_count]
+        identity = f"condition wait {opened.get('condition_wait_id')!r}"
         opened_key = opened.get("condition_key")
         if isinstance(opened_key, str) and opened_key != (cmd.condition_key or ""):
-            return FailWorkflow(
-                message=(
-                    "wait_condition key changed during replay: "
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_key_changed: {identity} wait_condition key changed during replay: "
                     f"history has {opened_key!r}, workflow yielded "
                     f"{cmd.condition_key!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         opened_fingerprint = opened.get("condition_definition_fingerprint")
@@ -5132,13 +5167,14 @@ def _replay_state(
             isinstance(opened_fingerprint, str)
             and cmd.condition_definition_fingerprint != opened_fingerprint
         ):
-            return FailWorkflow(
-                message=(
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_fingerprint_changed: {identity} "
                     "wait_condition predicate fingerprint changed during replay: "
                     f"history has {opened_fingerprint!r}, workflow yielded "
                     f"{cmd.condition_definition_fingerprint!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         return None
@@ -5172,6 +5208,7 @@ def _replay_state(
     except Exception as exc:
         return _state([_fail_workflow_from_exception(exc)])
     if not hasattr(gen, "__next__"):
+        _validate_workflow_result(gen, workflow_cls)
         if isinstance(gen, ContinueAsNew):
             _assert_no_unconsumed_history("continue as new")
             return _state([gen])
@@ -6032,6 +6069,7 @@ def _replay_state(
         return next(iter(memberships))
 
     def _terminal_state(value: Any, *, include_pending: bool) -> _ReplayState:
+        _validate_workflow_result(value, workflow_cls)
         _apply_due_receivers()
         _consume_terminal_condition_reopens()
         commands = list(pending) if include_pending else []
@@ -6624,7 +6662,7 @@ def _replay_state(
                         next_value = True
                         continue
                     if next_opened_mismatch is not None:
-                        return _state([next_opened_mismatch])
+                        raise next_opened_mismatch
                     step = _next_unconsumed_recorded_step()
                     if step is not None:
                         _assert_step_matches(cmd, step)
@@ -6676,7 +6714,7 @@ def _replay_state(
                         opened = wait_opened[wait_yield_count]
                         mismatch = _condition_wait_mismatch(opened, cmd)
                         if mismatch is not None:
-                            return _state([mismatch])
+                            raise mismatch
                         opened_id = opened.get("condition_wait_id")
                         if isinstance(opened_id, str):
                             resolution = wait_resolutions.get(opened_id)
@@ -6784,10 +6822,10 @@ def _replay_state(
         try:
             return _terminal_state(stop.value, include_pending=True)
         except Exception as exc:
-            if isinstance(exc, NonDeterministicReplayError):
+            if isinstance(exc, (NonDeterministicReplayError, InvalidWorkflowDefinition)):
                 raise
             return _state(pending + [_fail_workflow_from_exception(exc)])
-    except NonDeterministicReplayError:
+    except (NonDeterministicReplayError, InvalidWorkflowDefinition):
         raise
     except LocalActivityExecutionAborted:
         raise

{durable_workflow-2.5.1 → durable_workflow-2.5.3/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.1
+Version: 2.5.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/src/durable_workflow.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ tests/test_committed_cancellation_scope_descendants.py
 tests/test_committed_cancellation_scope_groups.py
 tests/test_committed_cancellation_scope_history.py
 tests/test_committed_cancellation_scope_replay.py
+tests/test_condition_replay_drift.py
 tests/test_control_plane_parity_fixtures.py
 tests/test_cooperative_cancellation.py
 tests/test_cooperative_cancellation_client.py
@@ -117,6 +118,7 @@ tests/test_updates.py
 tests/test_wait_condition.py
 tests/test_worker.py
 tests/test_worker_session.py
+tests/test_workflow_entrypoint_validation.py
 tests/test_workflow_result_timeout.py
 tests/test_workflow_streams.py
 tests/test_workflow_updates_conformance.py

durable_workflow-2.5.3/tests/test_condition_replay_drift.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from durable_workflow import Worker, serializer, workflow
+from durable_workflow.client import Client
+from durable_workflow.errors import NonDeterministicReplayError, QueryFailed
+from durable_workflow.workflow import WorkflowContext, apply_update, query_state, replay
+
+
+@workflow.defn(name="tests.replay.condition-identity")
+class ConditionIdentityWorkflow:
+    @workflow.query("state")
+    def state(self) -> str:
+        return "waiting"
+
+    @workflow.update("approve")
+    def approve(self) -> str:
+        return "approved"
+
+    def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+        yield ctx.wait_condition(lambda: False, key="approved")
+        return "done"
+
+
+def condition_history(field: str) -> list[dict]:
+    return [{
+        "event_type": "ConditionWaitOpened",
+        "payload": {
+            "sequence": 7,
+            "condition_wait_id": "wait-original",
+            "condition_key": "approved",
+            field: "old-key" if field == "condition_key" else "sha256:different",
+        },
+    }]
+
+
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["replay", "query", "update"])
+def test_condition_drift_is_not_a_business_failure(field: str, consumer: str) -> None:
+    history = condition_history(field)
+    error = QueryFailed if consumer == "query" else NonDeterministicReplayError
+    with pytest.raises(error) as captured:
+        if consumer == "query":
+            query_state(ConditionIdentityWorkflow, history, [], "state")
+        elif consumer == "update":
+            apply_update(ConditionIdentityWorkflow, history, [], "update-original")
+        else:
+            replay(ConditionIdentityWorkflow, history, [])
+
+    mismatch = captured.value.__cause__ if consumer == "query" else captured.value
+    assert isinstance(mismatch, NonDeterministicReplayError)
+    assert mismatch.workflow_sequence == 7
+    assert "wait-original" in str(mismatch)
+    assert "changed" in str(mismatch)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["workflow", "update"])
+async def test_worker_reports_drift_once_without_a_completion(field: str, consumer: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    task = {
+        "task_id": "task-original",
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "workflow_task_attempt": 2,
+        "history_events": condition_history(field),
+        "arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    }
+    if consumer == "update":
+        task["workflow_update_id"] = "update-original"
+
+    assert await worker._run_workflow_task_core(task) is None
+
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_awaited_once()
+    report = client.fail_workflow_task.await_args.kwargs
+    assert report["task_id"] == "task-original"
+    assert report["workflow_task_attempt"] == 2
+    assert report["lease_owner"] == worker.worker_id
+    assert report["failure_type"] == "NonDeterministicReplayError"
+    assert "wait-original" in report["message"]
+
+
+def test_application_predicate_failure_remains_terminal() -> None:
+    @workflow.defn(name="tests.condition-predicate-failure")
+    class PredicateFailure:
+        def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+            def predicate() -> bool:
+                raise ValueError("application failed")
+
+            yield ctx.wait_condition(predicate, key="approved")
+
+    outcome = replay(PredicateFailure, [], [])
+    assert len(outcome.commands) == 1
+    command = outcome.commands[0].to_server_command("condition-drift")
+    assert command["type"] == "fail_workflow"
+    assert command["exception_type"] == "ValueError"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+async def test_query_worker_reports_unavailable_state_without_changing_the_run(field: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    outcome = await worker._run_query_task({
+        "query_task_id": "query-original",
+        "query_task_attempt": 2,
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "query_name": "state",
+        "history_events": condition_history(field),
+        "workflow_arguments": serializer.envelope([], codec="avro"),
+        "query_arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    })
+
+    assert outcome == "failed"
+    client.complete_query_task.assert_not_awaited()
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_not_awaited()
+    client.fail_query_task.assert_awaited_once()
+    report = client.fail_query_task.await_args.kwargs
+    assert report["reason"] == "query_workflow_state_unavailable"
+    assert "wait-original" in report["message"]

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/tests/test_replay_regression_corpus.py

@@ -17,6 +17,7 @@ from durable_workflow.workflow import (
     commands_to_server_commands,
     query_state,
 )
+from tests.test_condition_replay_drift import ConditionIdentityWorkflow
 from tests.test_golden_history_replay import (
     GoldenSagaCompensationWorkflow,
     GoldenSignalWaitWorkflow,
@@ -251,7 +252,15 @@ class ChildPolicyAuthorWorkflow:
         return (yield ctx.start_child_workflow("child", []))
 
 
+class UnsupportedAsyncWorkflow:
+    __workflow_name__ = "tests.replay.unsupported-async"
+
+    async def run(self, ctx: WorkflowContext) -> str:
+        return "body was never executed"
+
+
 WORKFLOWS = [
+    UnsupportedAsyncWorkflow,
     ChildPolicyAuthorWorkflow,
     ColdReplacementSatisfiedConditionWorkflow,
     CooperativeReopenedConditionCleanupWorkflow,
@@ -283,6 +292,7 @@ WORKFLOWS = [
     YieldedContinueAfterMetadataWorkflow,
 ]
 WORKFLOW_TYPES = {str(getattr(workflow, "__workflow_name__", workflow.__name__)): workflow for workflow in WORKFLOWS}
+WORKFLOW_TYPES["tests.replay.condition-identity"] = ConditionIdentityWorkflow
 
 
 def _fixture_paths() -> list[Path]:

{durable_workflow-2.5.1 → durable_workflow-2.5.3}/tests/test_wait_condition.py

@@ -6,7 +6,6 @@ from durable_workflow import serializer, workflow
 from durable_workflow.errors import NonDeterministicReplayError
 from durable_workflow.workflow import (
     CompleteWorkflow,
-    FailWorkflow,
     WaitCondition,
     WorkflowContext,
     query_state,
@@ -1052,14 +1051,12 @@ class TestReplayWaitCondition:
             },
         ]
 
-        outcome = replay(WaitUntilApproved, history, [])
+        with pytest.raises(NonDeterministicReplayError, match="key changed") as captured:
+            replay(WaitUntilApproved, history, [])
 
-        assert len(outcome.commands) == 1
-        assert not isinstance(outcome.commands[0], CompleteWorkflow)
-        cmd = outcome.commands[0]
-        assert isinstance(cmd, FailWorkflow)
-        assert cmd.exception_type == "NonDeterministicWaitCondition"
-        assert "key changed" in cmd.message
+        assert captured.value.workflow_sequence == 1
+        assert "old-key" in str(captured.value)
+        assert "approved" in str(captured.value)
 
     def test_replay_rejects_changed_condition_fingerprint(self) -> None:
         initial = replay(WaitUntilApproved, [], [])
@@ -1077,14 +1074,12 @@ class TestReplayWaitCondition:
             },
         ]
 
-        outcome = replay(WaitUntilApproved, history, [])
+        with pytest.raises(NonDeterministicReplayError, match="predicate fingerprint changed") as captured:
+            replay(WaitUntilApproved, history, [])
 
-        assert len(outcome.commands) == 1
-        cmd = outcome.commands[0]
-        assert isinstance(cmd, FailWorkflow)
-        assert cmd.exception_type == "NonDeterministicWaitCondition"
-        assert "predicate fingerprint changed" in cmd.message
-        assert fingerprint in cmd.message
+        assert captured.value.workflow_sequence == 1
+        assert "sha256:different" in str(captured.value)
+        assert fingerprint in str(captured.value)
 
     def test_replay_accepts_matching_condition_fingerprint(self) -> None:
         initial = replay(WaitUntilApproved, [], [])

durable_workflow-2.5.3/tests/test_workflow_entrypoint_validation.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Generator
+from functools import partial, wraps
+from typing import Any
+
+import pytest
+
+from durable_workflow import Client, Worker, workflow
+from durable_workflow.testing import WorkflowEnvironment
+
+
+class CoroutineWorkflow:
+    async def run(self, ctx: Any) -> str:
+        return "never executed"
+
+
+class AsyncGeneratorWorkflow:
+    async def run(self, ctx: Any) -> AsyncIterator[str]:
+        yield "unsupported"
+
+
+class AsyncCallable:
+    async def __call__(self, ctx: Any) -> str:
+        return "unsupported"
+
+
+class CallableWorkflow:
+    run = AsyncCallable()
+
+
+class PartialWorkflow:
+    run = staticmethod(partial(CoroutineWorkflow.run, object()))
+
+
+ASYNC_DEFINITIONS = [CoroutineWorkflow, AsyncGeneratorWorkflow, CallableWorkflow, PartialWorkflow]
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_definition_rejects_async_entrypoints(definition: type) -> None:
+    with pytest.raises(ValueError, match="unsupported_workflow_entrypoint.*synchronous"):
+        workflow.defn(name="invalid-async")(definition)
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_worker_rejects_undecorated_async_entrypoints_before_network(definition: type) -> None:
+    with pytest.raises(ValueError, match=definition.__name__):
+        Worker(Client("http://127.0.0.1:1"), task_queue="unused", workflows=[definition])
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_direct_replay_rejects_async_without_creating_a_coroutine(definition: type) -> None:
+    with pytest.raises(ValueError, match="unsupported_workflow_entrypoint"):
+        workflow.replay(definition, [], [])
+
+
+def test_test_environment_revalidates_entrypoint_after_decoration() -> None:
+    @workflow.defn(name="changed-entrypoint")
+    class ChangedWorkflow:
+        def run(self, ctx: Any) -> str:
+            return "valid"
+
+    ChangedWorkflow.run = CoroutineWorkflow.run  # type: ignore[assignment]
+    with pytest.raises(ValueError, match="changed-entrypoint"):
+        WorkflowEnvironment().register_workflow(ChangedWorkflow)
+
+
+def test_wrapped_and_inherited_async_entrypoints_are_rejected() -> None:
+    class InheritedWorkflow(CoroutineWorkflow):
+        pass
+
+    class WrappedWorkflow:
+        @wraps(CoroutineWorkflow.run)
+        def run(self, ctx: Any) -> Any:
+            return CoroutineWorkflow.run(self, ctx)
+
+    for definition in [InheritedWorkflow, WrappedWorkflow]:
+        with pytest.raises(ValueError, match="unsupported_workflow_entrypoint"):
+            workflow.replay(definition, [], [])
+
+
+@pytest.mark.parametrize("generator", [False, True])
+def test_runtime_awaitable_result_is_not_completed(generator: bool) -> None:
+    class AwaitableResultWorkflow:
+        def run(self, ctx: Any) -> Any:
+            return CoroutineWorkflow.run(self, ctx)
+
+    class GeneratorAwaitableResultWorkflow:
+        def run(self, ctx: Any) -> Generator[Any, Any, Any]:
+            if False:
+                yield None
+            return CoroutineWorkflow.run(self, ctx)
+
+    definition = GeneratorAwaitableResultWorkflow if generator else AwaitableResultWorkflow
+    with pytest.raises(ValueError, match="unsupported_workflow_result"):
+        workflow.replay(definition, [], [])
+
+
+def test_synchronous_and_generator_workflows_remain_supported() -> None:
+    @workflow.defn(name="valid-sync")
+    class SynchronousWorkflow:
+        def run(self, ctx: Any) -> str:
+            return "done"
+
+    @workflow.defn(name="valid-generator")
+    class GeneratorWorkflow:
+        def run(self, ctx: Any) -> Generator[Any, Any, str]:
+            if False:
+                yield None
+            return "done"
+
+    Worker(Client("http://127.0.0.1:1"), task_queue="unused", workflows=[SynchronousWorkflow, GeneratorWorkflow])
+    environment = WorkflowEnvironment()
+    for definition in [SynchronousWorkflow, GeneratorWorkflow]:
+        assert environment.execute_workflow(definition) == "done"
+        assert workflow.replay(definition, [], []).commands[0].result == "done"  # type: ignore[union-attr]