durable-workflow 2.6.1__tar.gz → 2.6.2__tar.gz

{durable_workflow-2.6.1/src/durable_workflow.egg-info → durable_workflow-2.6.2}/PKG-INFO

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

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.6.1"
+version = "2.6.2"
 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.6.1"
-registry-version = "2.6.1"
+product-train = "2.6.2"
+registry-version = "2.6.2"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/__init__.py

@@ -103,6 +103,7 @@ from .errors import (
     UpdateValidationFailed,
     WorkflowAlreadyStarted,
     WorkflowCancelled,
+    WorkflowEntryArgumentsMismatchError,
     WorkflowFailed,
     WorkflowNotFound,
     WorkflowPayloadDecodeError,
@@ -319,6 +320,7 @@ __all__ = [
     "WorkflowHandle",
     "WorkflowList",
     "WorkflowPayloadDecodeError",
+    "WorkflowEntryArgumentsMismatchError",
     "WorkflowRun",
     "WorkflowRunList",
     "WorkflowStreamAppendItem",

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/activity.py

@@ -1,6 +1,7 @@
 """Activity decorator, registry, and execution context."""
 from __future__ import annotations
 
+import asyncio
 import contextvars
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
@@ -44,6 +45,10 @@ class ActivityContext:
         self._client = client
         self._heartbeat_callback = heartbeat_callback
         self._cancel_requested = False
+        try:
+            self._event_loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+        except RuntimeError:
+            self._event_loop = None
 
     @property
     def info(self) -> ActivityInfo:
@@ -55,6 +60,29 @@ class ActivityContext:
         """``True`` once the server has signalled that the owning workflow cancelled this activity."""
         return self._cancel_requested
 
+    def heartbeat_sync(self, details: dict[str, Any] | None = None) -> None:
+        """Heartbeat from a synchronous activity thread and observe cancellation.
+
+        The request runs on the worker's event loop using the original attempt
+        and client. Async handlers must use ``await heartbeat()`` instead.
+        """
+        loop = self._event_loop
+        if loop is None or not loop.is_running():
+            raise RuntimeError("heartbeat_sync requires a running worker event loop")
+        try:
+            caller_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            caller_loop = None
+        if caller_loop is loop:
+            raise RuntimeError("use await activity.context().heartbeat() on the worker event loop")
+        heartbeat = self.heartbeat(details)
+        try:
+            pending = asyncio.run_coroutine_threadsafe(heartbeat, loop)
+        except RuntimeError:
+            heartbeat.close()
+            raise
+        pending.result()
+
     async def heartbeat(self, details: dict[str, Any] | None = None) -> None:
         """Report liveness to the server and check for a cancellation request.
 

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/client.py

@@ -5312,15 +5312,20 @@ class Client:
         message: str,
         failure_type: str | None = None,
         stack_trace: str | None = None,
+        failure_reason: str | None = None,
     ) -> Any:
-        """Report a workflow task failure so the server can schedule a retry.
+        """Report a workflow task failure without closing the run.
 
         Worker-plane endpoint. Task failures (e.g. non-determinism) are
         distinct from workflow failures (``FailWorkflow`` commands).
+        The runtime may block incompatible replay until compatible code and
+        a supported repair are available instead of automatically retrying it.
         """
         failure: dict[str, Any] = {"message": message}
         if failure_type is not None:
             failure["type"] = failure_type
+        if failure_reason is not None:
+            failure["reason"] = failure_reason
         if stack_trace is not None:
             failure["stack_trace"] = stack_trace
         body: dict[str, Any] = {

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/errors.py

@@ -465,6 +465,21 @@ class WorkflowPayloadDecodeError(DurableWorkflowError):
         self.exception_type = exception_type
 
 
+class WorkflowEntryArgumentsMismatchError(DurableWorkflowError):
+    """Recorded input cannot bind to the deployed entry method before it runs."""
+
+    reason = "workflow_entry_arguments_mismatch"
+
+    def __init__(self, workflow_type: str, binding_reason: str) -> None:
+        self.workflow_type = workflow_type
+        self.entry_method = "run"
+        self.binding_reason = binding_reason
+        super().__init__(
+            f"{self.reason}: {workflow_type}.run cannot bind the recorded arguments "
+            f"({binding_reason}). Restore compatible code and repair the workflow task."
+        )
+
+
 class NonDeterministicReplayError(DurableWorkflowError):
     """Current workflow code yielded a command shape that does not match history."""
 

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/worker.py

@@ -79,6 +79,7 @@ from .errors import (
     ServerError,
     UpdateRejected,
     UpdateValidationFailed,
+    WorkflowEntryArgumentsMismatchError,
 )
 from .external_storage import ExternalPayloadCache, ExternalStorageDriver, store_external_payload
 from .interceptors import (
@@ -108,12 +109,13 @@ from .workflow import (
     StartChildWorkflow,
     UpsertMemo,
     _prepare_query_state,
+    _prepare_update_validation,
+    _UpdateValidationReplayOptions,
     _validate_workflow_entrypoint,
     _workflow_handler_registries,
     apply_update,
     commands_to_server_commands,
     replay,
-    validate_update,
 )
 
 log = logging.getLogger("durable_workflow.worker")
@@ -136,6 +138,7 @@ _WORKFLOW_COMMAND_CAPABILITIES = (
     TYPED_SEARCH_ATTRIBUTES_CAPABILITY,
     DURABLE_SELECTION_CAPABILITY,
     LOCAL_ACTIVITIES_CAPABILITY,
+    "workflow_entry_arguments_validation",
 )
 
 _WORKFLOW_WORK_TASK_KINDS = ("workflow", "update_validation")
@@ -2619,6 +2622,9 @@ class Worker:
             return None
         except Exception as e:
             log.exception("replay failed")
+            failure_details = (
+                {"failure_reason": e.reason} if isinstance(e, WorkflowEntryArgumentsMismatchError) else {}
+            )
             try:
                 await self.client.fail_workflow_task(
                     task_id=task_id,
@@ -2627,6 +2633,7 @@ class Worker:
                     message=f"replay failed: {e}",
                     failure_type=type(e).__name__,
                     stack_trace=traceback.format_exc(),
+                    **failure_details,
                 )
             except Exception as fe:
                 log.warning("failed to report replay failure: %s", fe)
@@ -3065,7 +3072,9 @@ class Worker:
             if self._cooperative_cancellation_supported:
                 result = await self._execute_cooperative_remote_callable(task, fn, tuple(args), act_ctx.info)
             else:
-                result = await self._execute_activity_callable(task, activity_type, tuple(args), fn)
+                result = await self._execute_activity_callable(
+                    task, activity_type, tuple(args), fn, run_sync_in_thread=True, remote=True,
+                )
         except _RemoteActivityExecutionAborted as error:
             log.warning("remote activity %s claim abandoned: %s", task_id, error)
             return "claim_aborted"
@@ -3859,21 +3868,24 @@ class Worker:
                 codec=codec,
                 context="workflow update validation arguments",
             )
-            result = validate_update(
+            invoke = _prepare_update_validation(
                 workflow_cls,
                 history,
                 start_input,
                 update_name,
                 update_args,
-                workflow_id=task.get("workflow_id"),
-                run_id=task.get("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,
+                replay_options=_UpdateValidationReplayOptions(
+                    workflow_id=task.get("workflow_id"),
+                    run_id=task.get("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,
+                ),
             )
+            result = invoke()
             if inspect.isawaitable(result):
                 result = await result
             if result is False:
@@ -4506,6 +4518,17 @@ class Worker:
                 )
             await asyncio.gather(*in_flight, return_exceptions=True)
 
+        # Cancelling the asyncio await cannot stop a running Python thread.
+        # Keep registration and capacity until the actual callback has returned.
+        while any(not future.done() for future in self._remote_activity_threads):
+            remaining = self._remaining_shutdown_time(deadline)
+            if remaining <= 0:
+                raise RuntimeError(
+                    "worker shutdown has unconfirmed activity thread stop(s); "
+                    "the worker registration remains active"
+                )
+            await asyncio.sleep(min(0.01, remaining))
+
         if self._local_activity_executor is not None:
             self._local_activity_executor.shutdown(wait=False, cancel_futures=True)
         if self._remote_activity_executor is not None:

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow/workflow.py

@@ -66,6 +66,7 @@ from .errors import (
     QueryFailed,
     SagaCompensationFailed,
     WorkflowCancelled,
+    WorkflowEntryArgumentsMismatchError,
     WorkflowPayloadDecodeError,
 )
 from .external_storage import ExternalPayloadCache, ExternalStorageDriver
@@ -137,6 +138,21 @@ def _workflow_handler_registries(
             wire_name = getattr(member, f"__{kind}_name__", None)
             if not isinstance(wire_name, str) or not wire_name:
                 continue
+            if not callable(member):
+                raise InvalidWorkflowDefinition(f"workflow {cls.__qualname__}.{attr} handler must be callable")
+            target = inspect.unwrap(member)
+            if not inspect.isroutine(target) and callable(target):
+                target = inspect.unwrap(target.__call__)
+            if (
+                (inspect.iscoroutinefunction(target) and kind not in {"query", "update_validator"})
+                or inspect.isasyncgenfunction(target)
+                or inspect.isgeneratorfunction(target)
+            ):
+                name = getattr(cls, "__workflow_name__", cls.__name__)
+                raise InvalidWorkflowDefinition(
+                    f"unsupported_workflow_handler: workflow {name!r} ({cls.__qualname__}.{attr}) "
+                    f"{kind} handler {wire_name!r} must be synchronous; yield durable commands from run()."
+                )
             if kind == "signal" and wire_name == MESSAGE_STREAM_SIGNAL:
                 raise ValueError(f"signal name {wire_name!r} is reserved by the workflow runtime")
             if wire_name in registry:
@@ -148,6 +164,28 @@ def _workflow_handler_registries(
     return handlers["signal"], handlers["query"], handlers["update"], handlers["update_validator"]
 
 
+def _invoke_workflow_handler(
+    handler: Callable[..., Any], args: list[Any], cls: type, method: str, *, allow_async: bool = False,
+) -> Any:
+    return _validate_workflow_handler_result(handler(*args), cls, method, allow_async=allow_async)
+
+
+def _validate_workflow_handler_result(result: Any, cls: type, method: str, *, allow_async: bool = False) -> Any:
+    if (
+        (inspect.isawaitable(result) and not allow_async)
+        or inspect.isasyncgen(result)
+        or inspect.isgenerator(result)
+    ):
+        if inspect.iscoroutine(result) or inspect.isgenerator(result):
+            result.close()
+        name = getattr(cls, "__workflow_name__", cls.__name__)
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_handler_result: workflow {name!r} ({cls.__qualname__}.{method}) "
+            "returned an async or generator value; handlers must return synchronous values."
+        )
+    return result
+
+
 def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     """Register a class as a workflow type under a language-neutral name.
 
@@ -3132,7 +3170,9 @@ def _prepare_query_state(
 
     def invoke() -> Any:
         try:
-            return handler(*(list(args) if args is not None else []))
+            return _invoke_workflow_handler(
+                handler, list(args) if args is not None else [], workflow_cls, method_name, allow_async=True,
+            )
         except QueryFailed:
             raise
         except Exception as exc:
@@ -3162,7 +3202,7 @@ def query_state(
     Server-routed Worker execution separately checks its original query claim
     between replay and handler invocation. Direct local use has no Server lease.
     """
-    return _prepare_query_state(
+    result = _prepare_query_state(
         workflow_cls, history_events, start_input, query_name, args,
         workflow_id=workflow_id, run_id=run_id, payload_codec=payload_codec,
         external_storage=external_storage, external_storage_cache=external_storage_cache,
@@ -3170,6 +3210,11 @@ def query_state(
         prepare_local_activity_groups=prepare_local_activity_groups,
         local_activity_cancellation_policies=local_activity_cancellation_policies,
     )()
+    try:
+        registry: dict[str, str] = getattr(workflow_cls, "__workflow_queries__", {}) or {}
+        return _validate_workflow_handler_result(result, workflow_cls, registry.get(query_name, query_name))
+    except InvalidWorkflowDefinition as exc:
+        raise QueryFailed(str(exc)) from exc
 
 
 def apply_update(
@@ -3275,11 +3320,24 @@ def apply_update(
         )
 
     try:
-        return CompleteUpdate(update_id=update_id, result=handler(*args))
+        result = _invoke_workflow_handler(handler, args, workflow_cls, method_name)
+        return CompleteUpdate(update_id=update_id, result=result)
     except Exception as exc:
         return _fail_update_from_exception(update_id, "update handler failed", exc)
 
 
+@dataclass(frozen=True)
+class _UpdateValidationReplayOptions:
+    workflow_id: str | None = None
+    run_id: str = ""
+    payload_codec: str | None = None
+    external_storage: ExternalStorageDriver | None = None
+    external_storage_cache: ExternalPayloadCache | None = None
+    prepare_local_activities: bool = False
+    prepare_local_activity_groups: bool = False
+    local_activity_cancellation_policies: tuple[str, ...] = ()
+
+
 def validate_update(
     workflow_cls: type,
     history_events: Iterable[dict[str, Any]],
@@ -3296,13 +3354,42 @@ def validate_update(
     prepare_local_activity_groups: bool = False,
     local_activity_cancellation_policies: tuple[str, ...] = (),
 ) -> Any:
+    """Replay and invoke a validator synchronously, refusing asynchronous results."""
+    from .errors import UpdateRejected
+
+    result = _prepare_update_validation(
+        workflow_cls, history_events, start_input, update_name, args,
+        replay_options=_UpdateValidationReplayOptions(
+            workflow_id=workflow_id, run_id=run_id, payload_codec=payload_codec,
+            external_storage=external_storage, external_storage_cache=external_storage_cache,
+            prepare_local_activities=prepare_local_activities,
+            prepare_local_activity_groups=prepare_local_activity_groups,
+            local_activity_cancellation_policies=local_activity_cancellation_policies,
+        ),
+    )()
+    try:
+        registry: dict[str, str] = getattr(workflow_cls, "__workflow_update_validators__", {}) or {}
+        return _validate_workflow_handler_result(result, workflow_cls, registry.get(update_name, update_name))
+    except InvalidWorkflowDefinition as exc:
+        raise UpdateRejected(str(exc), exception_type=type(exc).__name__) from exc
+
+
+def _prepare_update_validation(
+    workflow_cls: type,
+    history_events: Iterable[dict[str, Any]],
+    start_input: list[Any],
+    update_name: str,
+    args: list[Any],
+    *,
+    replay_options: _UpdateValidationReplayOptions,
+) -> Callable[[], Any]:
     """Replay state and invoke only the declared pre-accept update validator.
 
     The replayed instance is discarded after validation. This helper does not
     run the update handler and does not emit workflow commands, so the server
     remains the sole authority that can cross the accepted-state boundary.
     """
-    from .errors import InvalidArgument, UpdateRejected, UpdateValidationFailed
+    from .errors import UpdateValidationFailed
 
     events = list(history_events)
     try:
@@ -3310,14 +3397,14 @@ def validate_update(
             workflow_cls,
             events,
             start_input,
-            workflow_id=workflow_id,
-            run_id=run_id,
-            payload_codec=payload_codec,
-            external_storage=external_storage,
-            external_storage_cache=external_storage_cache,
-            prepare_local_activities=prepare_local_activities,
-            prepare_local_activity_groups=prepare_local_activity_groups,
-            local_activity_cancellation_policies=local_activity_cancellation_policies,
+            workflow_id=replay_options.workflow_id,
+            run_id=replay_options.run_id,
+            payload_codec=replay_options.payload_codec,
+            external_storage=replay_options.external_storage,
+            external_storage_cache=replay_options.external_storage_cache,
+            prepare_local_activities=replay_options.prepare_local_activities,
+            prepare_local_activity_groups=replay_options.prepare_local_activity_groups,
+            local_activity_cancellation_policies=replay_options.local_activity_cancellation_policies,
         )
     except Exception as exc:
         raise UpdateValidationFailed(
@@ -3348,8 +3435,20 @@ def validate_update(
     if validator is None:
         raise UpdateValidationFailed(f"update validator {update_name!r} is not available")
 
+    return lambda: _invoke_update_validator(validator, args, workflow_cls, validator_name, update_name)
+
+
+def _invoke_update_validator(
+    validator: Callable[..., Any],
+    args: list[Any],
+    workflow_cls: type,
+    validator_name: str,
+    update_name: str,
+) -> Any:
+    from .errors import InvalidArgument, UpdateRejected
+
     try:
-        result = validator(*list(args))
+        result = _invoke_workflow_handler(validator, list(args), workflow_cls, validator_name, allow_async=True)
         if result is False:
             raise ValueError(f"update validator {update_name!r} returned false")
         return result
@@ -4239,6 +4338,7 @@ def _replay_state(
     allow_cancellation_scope_delivery: bool = False,
 ) -> _ReplayState:
     _validate_workflow_entrypoint(workflow_cls)
+    _workflow_handler_registries(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:
@@ -5284,7 +5384,7 @@ def _replay_state(
                 return
             raise TypeError(f"update handler {receiver.name!r} is not available")
         ctx.logger._set_replaying(True)
-        handler(*receiver.args)
+        _invoke_workflow_handler(handler, receiver.args, workflow_cls, method_name)
 
     def _receiver_due(receiver: _PendingReceiver, *, before_consuming_result: bool) -> bool:
         if receiver.after_cancellation_delivery and not cancellation_consumed:
@@ -5386,8 +5486,21 @@ def _replay_state(
     result_cursor = 0
     pending_step_cursor = 0
     wait_yield_count = 0
+    entry = instance.run
+    workflow_type = str(getattr(workflow_cls, "__workflow_name__", workflow_cls.__name__))
+    try:
+        entry_signature = inspect.signature(entry)
+    except (TypeError, ValueError):
+        raise WorkflowEntryArgumentsMismatchError(workflow_type, "signature_unavailable") from None
+    try:
+        entry_signature.bind(ctx, *start_input)
+    except TypeError:
+        raise WorkflowEntryArgumentsMismatchError(workflow_type, "argument_binding_failed") from None
+
+    # Binding happens outside the application-error path. A TypeError raised
+    # by a successfully bound body is still an actual workflow failure.
     try:
-        gen = instance.run(ctx, *start_input)
+        gen = entry(ctx, *start_input)
     except NonDeterministicReplayError:
         raise
     except LocalActivityExecutionAborted:

{durable_workflow-2.6.1 → durable_workflow-2.6.2/src/durable_workflow.egg-info}/PKG-INFO

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

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/src/durable_workflow.egg-info/SOURCES.txt

@@ -120,6 +120,7 @@ tests/test_standalone_activity_client.py
 tests/test_sticky_execution.py
 tests/test_storage_admission.py
 tests/test_sync.py
+tests/test_sync_activities.py
 tests/test_testing_harness.py
 tests/test_update_signal_condition_replay.py
 tests/test_updates.py
@@ -127,7 +128,9 @@ tests/test_wait_condition.py
 tests/test_worker.py
 tests/test_worker_observation.py
 tests/test_worker_session.py
+tests/test_workflow_entry_arguments.py
 tests/test_workflow_entrypoint_validation.py
+tests/test_workflow_handler_validation.py
 tests/test_workflow_result_timeout.py
 tests/test_workflow_streams.py
 tests/test_workflow_updates_conformance.py

{durable_workflow-2.6.1 → durable_workflow-2.6.2}/tests/test_replay_regression_corpus.py

@@ -12,7 +12,12 @@ import pytest
 
 from durable_workflow import Replayer, Worker, serializer, workflow
 from durable_workflow.client import PROTOCOL_VERSION, Client, WorkflowExecution, WorkflowStreamAppendItem
-from durable_workflow.errors import NonDeterministicReplayError, WorkflowCancelled, WorkflowPayloadDecodeError
+from durable_workflow.errors import (
+    DurableWorkflowError,
+    NonDeterministicReplayError,
+    WorkflowCancelled,
+    WorkflowPayloadDecodeError,
+)
 from durable_workflow.replay_conformance import compose_report
 from durable_workflow.workflow import (
     LocalActivityExecutionAborted,
@@ -282,6 +287,23 @@ class UnsupportedAsyncWorkflow:
         return "body was never executed"
 
 
+class UnsupportedAsyncSignalWorkflow:
+    __workflow_name__ = "tests.replay.unsupported-async-signal"
+
+    @workflow.signal("change")
+    async def receive(self) -> None:
+        raise AssertionError("unsupported signal body must never run")
+
+    def run(self, ctx: WorkflowContext) -> str:
+        return "done"
+
+
+@workflow.defn(name="tests.replay.entry-arguments-required")
+class RequiredEntryArgumentWorkflow:
+    def run(self, ctx: WorkflowContext, amount: int, required: int) -> int:
+        raise AssertionError("incompatible entry body must never run")
+
+
 @workflow.defn(name="tests.replay.nexus-target")
 class NexusTargetWorkflow:
     def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
@@ -323,6 +345,7 @@ WORKFLOWS = [
     NexusTerminalDeliveryWorkflow,
     NexusTargetWorkflow,
     UnsupportedAsyncWorkflow,
+    UnsupportedAsyncSignalWorkflow,
     ChildPolicyAuthorWorkflow,
     ColdReplacementSatisfiedConditionWorkflow,
     CooperativeReopenedConditionCleanupWorkflow,
@@ -356,6 +379,7 @@ WORKFLOWS = [
 ]
 WORKFLOW_TYPES = {str(getattr(workflow, "__workflow_name__", workflow.__name__)): workflow for workflow in WORKFLOWS}
 WORKFLOW_TYPES["tests.replay.condition-identity"] = ConditionIdentityWorkflow
+WORKFLOW_TYPES["tests.replay.entry-arguments-required"] = RequiredEntryArgumentWorkflow
 
 
 def _fixture_paths() -> list[Path]:
@@ -558,6 +582,11 @@ def test_checked_in_replay_regression_corpus_uses_official_replayer(
         message = expected_replay_error.get("message_contains")
         assert isinstance(message, str) and message
         assert expected.get("command_sequence") == []
+        if expected_replay_error.get("type") == "WorkflowEntryArgumentsMismatchError":
+            with pytest.raises(DurableWorkflowError, match=message) as binding_error:
+                _execute_fixture(fixture)
+            assert type(binding_error.value).__name__ == "WorkflowEntryArgumentsMismatchError"
+            return
         if expected_replay_error.get("type") == "LocalActivityExecutionAborted":
             with pytest.raises(LocalActivityExecutionAborted, match=message):
                 _execute_fixture(fixture)