durable-workflow 2.14.1__tar.gz → 2.15.0__tar.gz

{durable_workflow-2.14.1/src/durable_workflow.egg-info → durable_workflow-2.15.0}/PKG-INFO

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

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.14.1"
+version = "2.15.0"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -79,8 +79,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.14.1"
-registry-version = "2.14.1"
+product-train = "2.15.0"
+registry-version = "2.15.0"
 supported-server-versions = "2.8.0"
 supported-server-release-baselines = { "2" = "2.8.0", "3" = "3.0.0" }
 worker-protocol-version = "1.20"

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/__init__.py

@@ -52,6 +52,9 @@ from .client import (
     TaskQueueList,
     TaskQueueQueryAdmission,
     TaskQueueTaskAdmission,
+    WorkflowActivity,
+    WorkflowActivityAttempt,
+    WorkflowActivityList,
     WorkflowCommandResult,
     WorkflowExecution,
     WorkflowHandle,
@@ -90,6 +93,7 @@ from .errors import (
     NonRetryableError,
     QueryFailed,
     QueryTaskAuthorityLost,
+    ReplayClockUnavailable,
     RuntimeCapabilityUnsupported,
     RuntimeDiscoveryUnavailable,
     SagaCompensationFailed,
@@ -331,6 +335,9 @@ __all__ = [
     "WorkflowEntryArgumentsMismatchError",
     "WorkflowRun",
     "WorkflowRunList",
+    "WorkflowActivity",
+    "WorkflowActivityAttempt",
+    "WorkflowActivityList",
     "WorkflowStreamAppendItem",
     "WorkflowStreamAppendResult",
     "WorkflowStreamDescription",
@@ -383,6 +390,7 @@ __all__ = [
     "NexusOperationResult",
     "NexusServiceCall",
     "NonDeterministicReplayError",
+    "ReplayClockUnavailable",
     "DuplicateRegistrationError",
     "InvalidWorkflowDefinition",
     "NoopMetrics",

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/_typed_values.py

@@ -255,22 +255,22 @@ def to_payload_values(values: list[Any]) -> list[Any]:
     return [to_payload_value(value) for value in values]
 
 
-def typed_callable(fn: Callable[..., Any]) -> Callable[..., Any]:
-    """Wrap *fn* so positional arguments decode to its annotations.
+def _positional_decoder(
+    fn: Callable[..., Any], skip: int, where: str,
+) -> Callable[[tuple[Any, ...]], list[Any]] | None:
+    """Build a decoder for *fn*'s positional arguments after the first *skip*.
 
-    Annotations are validated here, so an unsupported type fails when the
-    activity is declared. The wrapper keeps *fn*'s module and qualified name:
-    the decorator binds that name to the wrapper, so supervised callbacks that
-    pickle by reference resolve to it.
+    Returns None when no argument needs decoding (none, or only ``Any`` /
+    unannotated ones), so the caller can leave *fn* unwrapped.
     """
     signature = inspect.signature(fn)
     try:
         hints = get_type_hints(fn)
     except (NameError, TypeError) as error:
-        raise TypeError(f"typed activity {fn.__qualname__} has unresolvable annotations: {error}") from None
+        raise TypeError(f"{where} {fn.__qualname__} has unresolvable annotations: {error}") from None
     positional: list[tuple[str, Any]] = []
     variadic: tuple[str, Any] | None = None
-    for parameter in signature.parameters.values():
+    for parameter in list(signature.parameters.values())[skip:]:
         annotation = hints.get(parameter.name, Any)
         if parameter.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD):
             validate_annotation(annotation, parameter.name)
@@ -279,6 +279,10 @@ def typed_callable(fn: Callable[..., Any]) -> Callable[..., Any]:
             validate_annotation(annotation, parameter.name)
             variadic = (parameter.name, annotation)
 
+    annotations = [annotation for _, annotation in positional] + ([variadic[1]] if variadic is not None else [])
+    if all(annotation in _PASS_THROUGH for annotation in annotations):
+        return None
+
     def convert(args: tuple[Any, ...]) -> list[Any]:
         converted: list[Any] = []
         for index, value in enumerate(args):
@@ -292,6 +296,22 @@ def typed_callable(fn: Callable[..., Any]) -> Callable[..., Any]:
                 converted.append(value)
         return converted
 
+    return convert
+
+
+def typed_callable(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """Wrap an activity so positional arguments decode to its annotations.
+
+    Annotations are validated here, so an unsupported type fails when the
+    activity is declared. The wrapper keeps *fn*'s module and qualified name:
+    the decorator binds that name to the wrapper, so supervised callbacks that
+    pickle by reference resolve to it.
+    """
+    decoder = _positional_decoder(fn, 0, "typed activity")
+
+    def convert(args: tuple[Any, ...]) -> list[Any]:
+        return list(args) if decoder is None else decoder(args)
+
     wrapper: Any
     if inspect.iscoroutinefunction(fn):
 
@@ -309,3 +329,42 @@ def typed_callable(fn: Callable[..., Any]) -> Callable[..., Any]:
         wrapper = typed_sync
     wrapper.__typed_activity__ = fn
     return cast(Callable[..., Any], wrapper)
+
+
+def typed_method(fn: Callable[..., Any], skip: int) -> Callable[..., Any]:
+    """Wrap a workflow method so arguments after the first *skip* decode.
+
+    ``skip`` is 1 for handlers (``self``) and 2 for ``run`` (``self, ctx``). A
+    generator ``run`` stays a generator. Results are returned unchanged; the
+    commands that carry them send dataclass and Enum values as neutral values.
+    A method with nothing to decode is returned unwrapped.
+    """
+    convert = _positional_decoder(fn, skip, "typed workflow method")
+    if convert is None:
+        # Nothing to decode: keep the original function, so a handler used as a
+        # wait_condition predicate keeps its recorded fingerprint.
+        return fn
+    wrapper: Any
+    if inspect.isgeneratorfunction(fn):
+
+        @functools.wraps(fn)
+        def typed_generator(*args: Any, **kwargs: Any) -> Any:
+            return (yield from fn(*args[:skip], *convert(args[skip:]), **kwargs))
+
+        wrapper = typed_generator
+    elif inspect.iscoroutinefunction(fn):
+
+        @functools.wraps(fn)
+        async def typed_async(*args: Any, **kwargs: Any) -> Any:
+            return await fn(*args[:skip], *convert(args[skip:]), **kwargs)
+
+        wrapper = typed_async
+    else:
+
+        @functools.wraps(fn)
+        def typed_sync(*args: Any, **kwargs: Any) -> Any:
+            return fn(*args[:skip], *convert(args[skip:]), **kwargs)
+
+        wrapper = typed_sync
+    wrapper.__typed_workflow_method__ = fn
+    return cast(Callable[..., Any], wrapper)

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/activity.py

@@ -82,6 +82,7 @@ class ActivityInfo:
     retry_info: ActivityRetryInfo = field(init=False)
     workflow_id: str | None = field(init=False)
     run_id: str | None = field(init=False)
+    activity_execution_id: str | None = field(init=False)
 
     def __post_init__(self, task_metadata: Mapping[str, Any] | None) -> None:
         task = task_metadata if task_metadata is not None else {}
@@ -89,6 +90,9 @@ class ActivityInfo:
         for name in ("workflow_id", "run_id"):
             value = task.get(name)
             object.__setattr__(self, name, value if isinstance(value, str) and value else None)
+        execution_id = task.get("activity_execution_id")
+        object.__setattr__(self, "activity_execution_id",
+                           execution_id if isinstance(execution_id, str) and execution_id.strip() else None)
 
 
 class ActivityContext:

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/client.py

@@ -62,6 +62,7 @@ from ._poll_transport import POLL_PATHS as _POLL_PATHS
 from ._poll_transport import unwrap_response as _unwrap_poll_response
 from ._poll_transport import warn_early_cutoff as _warn_poll_cutoff
 from ._query_task_authority import QueryTaskAuthority, current_query_authority
+from ._typed_values import decode_payload_value, to_payload_values, validate_annotation
 from .errors import (
     REQUEST_ID_CONFLICT,
     ExternalPayloadIntegrityMismatch,
@@ -377,6 +378,33 @@ class _RuntimeExternalPayloadTransport:
     prepared_completion_context: bool = False
 
 
+class _PageTokens:
+    """Detect cyclic opaque continuations with constant-space checkpoints."""
+
+    def __init__(self, token: str | None) -> None:
+        self.current = token
+        self._checkpoint = token
+        self._distance = 0
+        self._power = 1
+
+    def advance(self, token: Any) -> bool:
+        if token is None or token == "":
+            self.current = None
+            return False
+        if not isinstance(token, str):
+            raise RuntimeError("pagination returned an invalid page token")
+        if token == self.current or token == self._checkpoint:
+            raise RuntimeError("pagination repeated a page token")
+        self.current = token
+        self._distance += 1
+        # Brent's cycle detector retains one checkpoint, not every old token.
+        if self._distance == self._power:
+            self._checkpoint = token
+            self._power *= 2
+            self._distance = 0
+        return True
+
+
 @dataclass
 class WorkflowExecution:
     """Current server view of one workflow execution."""
@@ -698,6 +726,133 @@ class WorkflowRunList:
     runs: list[WorkflowRun]
 
 
+@dataclass
+class WorkflowActivityAttempt:
+    """Received attempt visibility. Missing metadata stays unavailable."""
+
+    id: str | None = None
+    worker_attempt_id: str | None = None
+    attempt_number: int | None = None
+    status: str | None = None
+    task_id: str | None = None
+    lease_owner: str | None = None
+    lease_expires_at: str | None = None
+    started_at: str | None = None
+    last_heartbeat_at: str | None = None
+    last_heartbeat_progress: dict[str, Any] | list[Any] | None = None
+    closed_at: str | None = None
+    can_continue: bool | None = None
+    cancel_requested: bool | None = None
+    stop_reason: str | None = None
+    failure_reason: str | None = None
+    raw: dict[str, Any] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> WorkflowActivityAttempt:
+        values = {name: _run_activity_field(data, name, str) for name in (
+            "id", "worker_attempt_id", "status", "task_id", "lease_owner", "lease_expires_at", "started_at",
+            "last_heartbeat_at", "closed_at", "stop_reason", "failure_reason",
+        )}
+        return cls(**values, attempt_number=_run_activity_field(data, "attempt_number", int),
+                   can_continue=_run_activity_field(data, "can_continue", bool),
+                   cancel_requested=_run_activity_field(data, "cancel_requested", bool),
+                   last_heartbeat_progress=_run_activity_progress(data), raw=copy.deepcopy(data))
+
+
+@dataclass
+class WorkflowActivity:
+    """Activity metadata from one run, retaining Server diagnostic authority."""
+
+    id: str | None = None
+    idempotency_key: str | None = None
+    sequence: int | None = None
+    activity_type: str | None = None
+    activity_class: str | None = None
+    execution_mode: str | None = None
+    local_activity: bool | None = None
+    history_authority: str | None = None
+    diagnostic_only: bool | None = None
+    history_event_types: list[str] | None = None
+    history_unsupported_reason: str | None = None
+    reused_from_run_id: str | None = None
+    reused_activity_execution_id: str | None = None
+    reused_recorded_at: str | None = None
+    row_status: str | None = None
+    parallel_group_kind: str | None = None
+    parallel_group_id: str | None = None
+    parallel_group_base_sequence: int | None = None
+    parallel_group_size: int | None = None
+    parallel_group_index: int | None = None
+    parallel_group_path: list[dict[str, Any]] | None = None
+    attempt_id: str | None = None
+    worker_attempt_id: str | None = None
+    status: str | None = None
+    attempt_count: int | None = None
+    retry_policy: Any = None
+    connection: str | None = None
+    queue: str | None = None
+    last_heartbeat_at: str | None = None
+    last_heartbeat_progress: dict[str, Any] | list[Any] | None = None
+    created_at: str | None = None
+    started_at: str | None = None
+    closed_at: str | None = None
+    attempts: list[WorkflowActivityAttempt] | None = None
+    raw: dict[str, Any] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> WorkflowActivity:
+        values = {name: _run_activity_field(data, name, str) for name in (
+            "id", "idempotency_key", "execution_mode", "history_authority", "history_unsupported_reason",
+            "reused_from_run_id", "reused_activity_execution_id", "reused_recorded_at", "row_status",
+            "parallel_group_kind", "parallel_group_id", "attempt_id", "worker_attempt_id", "status",
+            "connection", "queue", "last_heartbeat_at", "created_at", "started_at", "closed_at",
+        )}
+        for name in ("sequence", "parallel_group_base_sequence", "parallel_group_size", "parallel_group_index",
+                     "attempt_count"):
+            values[name] = _run_activity_field(data, name, int)
+        for name in ("local_activity", "diagnostic_only"):
+            values[name] = _run_activity_field(data, name, bool)
+        attempts = _run_activity_items(data, "attempts", dict)
+        return cls(**values, activity_type=_run_activity_field(data, "type", str),
+                   activity_class=_run_activity_field(data, "class", str),
+                   history_event_types=_run_activity_items(data, "history_event_types", str),
+                   parallel_group_path=_run_activity_items(data, "parallel_group_path", dict),
+                   attempts=[WorkflowActivityAttempt.from_dict(item) for item in attempts]
+                   if attempts is not None else None,
+                   last_heartbeat_progress=_run_activity_progress(data),
+                   retry_policy=copy.deepcopy(data.get("retry_policy")), raw=copy.deepcopy(data))
+
+
+@dataclass
+class WorkflowActivityList:
+    """One explicit run's activity visibility, distinct from standalone jobs."""
+
+    workflow_id: str
+    run_id: str
+    activities: list[WorkflowActivity]
+
+
+def _run_activity_field(data: dict[str, Any], name: str, kind: type[Any]) -> Any:
+    value = data.get(name)
+    if value is not None and type(value) is not kind:
+        raise RuntimeError(f"invalid run activity field: {name}")
+    return value
+
+
+def _run_activity_items(data: dict[str, Any], name: str, kind: type[Any]) -> Any:
+    items = _run_activity_field(data, name, list)
+    if items is not None and any(type(item) is not kind for item in items):
+        raise RuntimeError(f"invalid run activity items: {name}")
+    return items
+
+
+def _run_activity_progress(data: dict[str, Any]) -> Any:
+    value = data.get("last_heartbeat_progress")
+    if value is not None and not isinstance(value, (dict, list)):
+        raise RuntimeError("invalid run activity field: last_heartbeat_progress")
+    return copy.deepcopy(value)
+
+
 @dataclass
 class StandaloneActivityExecution:
     """Server view of one standalone activity execution.
@@ -1328,6 +1483,12 @@ class BridgeAdapterOutcome:
         )
 
 
+# Client payloads that carry caller arguments.
+_ARGUMENT_PAYLOAD_KINDS = frozenset({
+    "workflow_input", "signal", "update", "query", "activity_input", "schedule_input",
+})
+
+
 class WorkflowHandle:
     """Convenience wrapper for operating on one workflow ID."""
 
@@ -1337,9 +1498,11 @@ class WorkflowHandle:
         self.run_id = run_id
         self.workflow_type = workflow_type
 
-    async def result(self, *, poll_interval: float = 0.5, timeout: float = 30.0) -> Any:
+    async def result(self, *, poll_interval: float = 0.5, timeout: float = 30.0, result_type: Any = None) -> Any:
         """Block until this workflow terminates and return its result. See :meth:`Client.get_result`."""
-        return await self._client.get_result(self, poll_interval=poll_interval, timeout=timeout)
+        return await self._client.get_result(
+            self, poll_interval=poll_interval, timeout=timeout, result_type=result_type,
+        )
 
     async def describe(self) -> WorkflowExecution:
         """Return the server's current view of this workflow. See :meth:`Client.describe_workflow`."""
@@ -1367,6 +1530,17 @@ class WorkflowHandle:
             raise ValueError("run_id is required to export workflow history from a handle")
         return await self._client.export_history(self.workflow_id, self.run_id)
 
+    async def iter_history(
+        self, *, page_size: int | None = None, next_page_token: str | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Yield this explicit run's history. See :meth:`Client.iter_history`."""
+        if self.run_id is None:
+            raise ValueError("run_id is required to iterate workflow history from a handle")
+        async for event in self._client.iter_history(
+            self.workflow_id, self.run_id, page_size=page_size, next_page_token=next_page_token,
+        ):
+            yield event
+
     async def list_runs(self) -> WorkflowRunList:
         """List all runs in this workflow execution chain. See :meth:`Client.list_workflow_runs`."""
         return await self._client.list_workflow_runs(self.workflow_id)
@@ -1378,6 +1552,13 @@ class WorkflowHandle:
             raise ValueError("run_id is required to describe a workflow run from a handle")
         return await self._client.describe_workflow_run(self.workflow_id, selected_run_id)
 
+    async def get_activities(self, run_id: str | None = None) -> WorkflowActivityList:
+        """Read activities for an explicit run. See :meth:`Client.get_run_activities`."""
+        selected_run_id = self.run_id if run_id is None else run_id
+        if selected_run_id is None:
+            raise ValueError("run_id is required to fetch workflow activities from a handle")
+        return await self._client.get_run_activities(self.workflow_id, selected_run_id)
+
     async def signal(
         self,
         signal_name: str,
@@ -1807,6 +1988,11 @@ class Client:
         external_storage: ExternalStorageDriver | None = None,
         external_storage_threshold_bytes: int | None = None,
     ) -> dict[str, Any]:
+        if kind in _ARGUMENT_PAYLOAD_KINDS and isinstance(value, list):
+            # Dataclass and Enum arguments travel as their neutral values, the
+            # bytes dataclasses.asdict() and .value give. The codec refuses
+            # those values, so no existing caller depends on this conversion.
+            value = to_payload_values(value)
         warning_context = self._payload_context(
             kind=kind,
             workflow_id=workflow_id,
@@ -3857,6 +4043,39 @@ class Client:
             next_page_token=data.get("next_page_token"),
         )
 
+    async def iter_workflows(
+        self,
+        *,
+        workflow_type: str | None = None,
+        status: str | None = None,
+        query: str | None = None,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> AsyncIterator[WorkflowExecution]:
+        """Yield workflow list results lazily, retaining no previous pages.
+
+        Filters and namespace stay fixed across pages. An empty page with a
+        continuation is followed; missing/empty continuation ends iteration.
+        Cancellation, malformed/cyclic continuations and HTTP errors propagate,
+        possibly after earlier results have been yielded. This is a traversal
+        of Server pages, not a snapshot of concurrently changing workflows.
+        """
+        tokens = _PageTokens(next_page_token)
+        namespace = self.namespace
+        while True:
+            if self.namespace != namespace:
+                raise RuntimeError("client namespace changed during pagination")
+            page = await self.list_workflows(
+                workflow_type=workflow_type, status=status, query=query, page_size=page_size,
+                next_page_token=tokens.current,
+            )
+            more = tokens.advance(page.next_page_token)
+            for execution in page.executions:
+                yield execution
+            del page
+            if not more:
+                return
+
     async def get_history(
         self,
         workflow_id: str,
@@ -3879,6 +4098,39 @@ class Client:
             "GET", path, context=workflow_id
         )
 
+    async def iter_history(
+        self,
+        workflow_id: str,
+        run_id: str,
+        *,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Yield run-history events in Server order, fetching one page at a time.
+
+        Workflow/run/namespace identity and page size stay fixed. Stopping the
+        iterator fetches no subsequent page. Empty continued pages are followed;
+        malformed/cyclic continuations and HTTP errors propagate rather than
+        appearing as a complete history. Already yielded events are not undone.
+        """
+        tokens = _PageTokens(next_page_token)
+        namespace = self.namespace
+        while True:
+            if self.namespace != namespace:
+                raise RuntimeError("client namespace changed during pagination")
+            page = await self.get_history(
+                workflow_id, run_id, page_size=page_size, next_page_token=tokens.current,
+            )
+            if (not isinstance(page, dict) or not isinstance(page.get("events"), list)
+                    or any(not isinstance(event, dict) for event in page["events"])):
+                raise RuntimeError("history pagination returned invalid events")
+            more = tokens.advance(page.get("next_page_token"))
+            for event in page["events"]:
+                yield event
+            del page
+            if not more:
+                return
+
     async def export_history(self, workflow_id: str, run_id: str) -> Any:
         """Export one workflow run history as a replay bundle."""
         return await self._request(
@@ -3898,6 +4150,25 @@ class Client:
             runs=runs,
         )
 
+    async def get_run_activities(self, workflow_id: str, run_id: str) -> WorkflowActivityList:
+        """Read typed activity/attempt metadata for this namespace and exact run.
+
+        Missing optional metadata stays None. Diagnostic/unsupported states and
+        unknown future status strings are preserved; this visibility snapshot
+        does not grant attempt authority. Payloads are not fetched or decoded.
+        """
+        data = await self._request(
+            "GET", f"/workflows/{quote(workflow_id, safe='._:-')}/runs/{quote(run_id, safe='._:-')}/activities",
+            context=workflow_id,
+        )
+        if (not isinstance(data, dict) or data.get("workflow_id") != workflow_id
+                or data.get("run_id") != run_id):
+            raise RuntimeError("run activity response changed workflow/run identity")
+        items = _run_activity_items(data, "activities", dict)
+        if items is None:
+            raise RuntimeError("run activity response omitted activities")
+        return WorkflowActivityList(workflow_id, run_id, [WorkflowActivity.from_dict(item) for item in items])
+
     async def describe_workflow_run(self, workflow_id: str, run_id: str) -> WorkflowRun:
         """Return detailed status, payload, and actionability for one specific workflow run."""
         data = await self._request("GET", f"/workflows/{workflow_id}/runs/{run_id}", context=workflow_id)
@@ -4760,9 +5031,16 @@ class Client:
         *,
         poll_interval: float = 0.5,
         timeout: float = 30.0,
+        result_type: Any = None,
     ) -> Any:
         """Poll a workflow until it reaches a terminal state and return its result.
 
+        ``result_type`` opts in to decoding the result to that annotation
+        (the types :func:`durable_workflow.activity.defn` lists for
+        ``typed=True``); a mismatch raises
+        :class:`~durable_workflow.errors.TypedValueError`, which names the
+        field path but never the value. Without it the plain value is returned.
+
         Raises :class:`~durable_workflow.errors.WorkflowFailed`,
         :class:`~durable_workflow.errors.WorkflowCancelled`, or
         :class:`~durable_workflow.errors.WorkflowTerminated` if the workflow
@@ -4770,6 +5048,8 @@ class Client:
         raises :class:`~durable_workflow.errors.WorkflowTimedOut`; a caller's
         :class:`TimeoutError` means ``timeout`` seconds elapsed while waiting.
         """
+        if result_type is not None:
+            validate_annotation(result_type, "result_type")
         deadline = asyncio.get_running_loop().time() + timeout
         while True:
             desc = await self.describe_workflow(handle.workflow_id)
@@ -4789,12 +5069,15 @@ class Client:
                         etype = ev.get("event_type")
                         payload = ev.get("payload") or {}
                         if etype == "WorkflowCompleted":
-                            return serializer.decode_envelope(
+                            output = serializer.decode_envelope(
                                 payload.get("output"),
                                 codec=payload.get("payload_codec") or desc.payload_codec,
                                 external_storage=self.external_storage,
                                 external_storage_cache=self.external_storage_cache,
                             )
+                            if result_type is None:
+                                return output
+                            return decode_payload_value(output, result_type, "workflow result")
                         if etype == "WorkflowFailed":
                             raise WorkflowFailed(
                                 payload.get("message", "workflow failed"),

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/errors.py

@@ -27,6 +27,13 @@ class DurableWorkflowError(Exception):
     """Base class for every exception raised by the SDK."""
 
 
+class ReplayClockUnavailable(DurableWorkflowError):
+    """The current execution has no proved business replay-time boundary."""
+
+    def __init__(self) -> None:
+        super().__init__("business replay time is unavailable at this execution boundary")
+
+
 class FailureReportTooLarge(DurableWorkflowError, ValueError):
     """Required failure identity or semantics cannot fit the reporting budget.
 

{durable_workflow-2.14.1 → durable_workflow-2.15.0}/src/durable_workflow/metrics.py

@@ -26,6 +26,7 @@ WORKER_POLLS = "durable_workflow_worker_polls"
 WORKER_POLL_DURATION_SECONDS = "durable_workflow_worker_poll_duration_seconds"
 WORKER_TASKS = "durable_workflow_worker_tasks"
 WORKER_TASK_DURATION_SECONDS = "durable_workflow_worker_task_duration_seconds"
+WORKER_TASK_SCHEDULE_TO_START_SECONDS = "durable_workflow_worker_task_schedule_to_start_seconds"
 
 
 class MetricsRecorder(Protocol):