durable-workflow 2.11.1__tar.gz → 2.12.0__tar.gz

{durable_workflow-2.11.1/src/durable_workflow.egg-info → durable_workflow-2.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.11.1
+Version: 2.12.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.11.1 → durable_workflow-2.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.11.1"
+version = "2.12.0"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -76,8 +76,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.11.1"
-registry-version = "2.11.1"
+product-train = "2.12.0"
+registry-version = "2.12.0"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/src/durable_workflow/__init__.py

@@ -7,7 +7,7 @@ except PackageNotFoundError:  # source checkout without installed metadata
     __version__ = "0.0.0+unknown"
 
 from . import activity, sync, testing, workflow
-from .activity import ActivityContext, ActivityInfo
+from .activity import ActivityContext, ActivityInfo, ActivityRetryInfo
 from .auth_composition import (
     AUTH_COMPOSITION_CONTRACT_SCHEMA,
     AUTH_COMPOSITION_CONTRACT_VERSION,
@@ -248,6 +248,7 @@ __all__ = [
     "ActivityContext",
     "ActivityHandler",
     "ActivityInfo",
+    "ActivityRetryInfo",
     "ActivityInterceptorContext",
     "ActivityRetryPolicy",
     "BridgeAdapterOutcome",

durable_workflow-2.12.0/src/durable_workflow/_poll_transport.py

@@ -0,0 +1,55 @@
+"""Negotiated long-poll responses and early transport failure diagnostics."""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Mapping
+from typing import Any
+
+import httpx
+
+MEDIA_TYPE = "application/vnd.durable-workflow.poll.v1+json"
+ACCEPT = f"{MEDIA_TYPE}, application/json;q=0.9"
+_SCHEMA = "durable-workflow.poll-transport.v1"
+POLL_PATHS = frozenset(
+    f"/worker/{kind}-tasks/poll" for kind in ("workflow", "activity", "query", "update-validation")
+)
+_HEADERS = frozenset(("retry-after", "x-durable-workflow-protocol-version"))
+log = logging.getLogger(__name__)
+
+
+def unwrap_response(response: httpx.Response) -> httpx.Response:
+    if response.headers.get("content-type", "").split(";", 1)[0].strip().lower() != MEDIA_TYPE:
+        return response
+
+    try:
+        envelope = response.json()
+        if not isinstance(envelope, dict) or envelope.get("schema") != _SCHEMA:
+            raise ValueError("unrecognized poll transport")
+        status, headers, body = envelope.get("status"), envelope.get("headers"), envelope.get("body")
+        if (type(status) is not int or not 200 <= status < 600
+                or response.status_code not in (200, status)
+                or not isinstance(body, dict) or not isinstance(headers, dict)
+                or any(key not in _HEADERS or not isinstance(value, str)
+                       or "\r" in value or "\n" in value for key, value in headers.items())):
+            raise ValueError("invalid poll transport result")
+        # Apply the original status and retry headers before the normal client
+        # error handling. Outer HTTP 200 may have been committed by progress.
+        return httpx.Response(status, headers=headers, json=body, request=response.request)
+    except (ValueError, TypeError) as error:
+        raise httpx.RemoteProtocolError("Invalid worker poll transport response.", request=response.request) from error
+
+
+def warn_early_cutoff(path: str, body: Any, started: float, error: Exception) -> None:
+    wait = body.get("timeout_seconds") if isinstance(body, Mapping) else None
+    observed = time.monotonic() - started
+    if isinstance(wait, bool) or not isinstance(wait, int | float) or wait <= 0 or observed >= wait:
+        return
+    if isinstance(error, httpx.HTTPStatusError) and error.response.status_code not in (502, 504):
+        return
+    log.warning(
+        "Worker long poll %s ended after %.3fs before its configured wait of %.3fs (%s). "
+        "Check proxy and HTTP timeout budgets.",
+        path, observed, wait, type(error).__name__,
+    )

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/src/durable_workflow/activity.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 
 import asyncio
 import contextvars
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
+import json
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import InitVar, dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from ._activity_lease import current_activity_authority
@@ -20,6 +21,53 @@ _current_context: contextvars.ContextVar[ActivityContext | None] = contextvars.C
 )
 
 
+@dataclass(frozen=True, init=False)
+class ActivityRetryInfo:
+    """Original attempt and immutable received retry snapshot, without defaults."""
+
+    attempt_number: int
+    policy_provided: bool
+    # Immutable JSON also survives the supervised callback's spawn serialization.
+    _policy_json: str = field(repr=False)
+
+    def __init__(self, attempt_number: int, policy_provided: bool = False, policy: Any = None) -> None:
+        object.__setattr__(self, "attempt_number", attempt_number)
+        object.__setattr__(self, "policy_provided", policy_provided)
+        object.__setattr__(self, "_policy_json", json.dumps(policy))
+
+    @classmethod
+    def from_task(cls, attempt_number: int, task: Mapping[str, Any]) -> ActivityRetryInfo:
+        return cls(attempt_number, "retry_policy" in task, task.get("retry_policy"))
+
+    def policy(self) -> Any:
+        """Return a fresh copy, including unknown fields and explicit legacy null."""
+        return json.loads(self._policy_json)
+
+    def max_attempts(self) -> int | None:
+        """A positive configured limit. An unknown limit does not mean unlimited."""
+        policy = self.policy()
+        maximum = policy.get("max_attempts") if isinstance(policy, dict) else None
+        return maximum if type(maximum) is int and maximum > 0 else None
+
+    def is_unlimited(self) -> bool:
+        """Only an explicit max_attempts:null inside a policy means unlimited."""
+        policy = self.policy()
+        return isinstance(policy, dict) and "max_attempts" in policy and policy["max_attempts"] is None
+
+    def is_last_configured_attempt(self) -> bool | None:
+        """Check the budget, not whether another execution will actually occur.
+
+        Cancellation, non-retryable failure, workflow closure and deadlines can
+        end execution before the configured budget is exhausted.
+        """
+        if self.attempt_number < 1:
+            return None
+        maximum = self.max_attempts()
+        if maximum is not None:
+            return self.attempt_number >= maximum
+        return False if self.is_unlimited() else None
+
+
 @dataclass(frozen=True)
 class ActivityInfo:
     """Metadata attached to the currently running activity attempt."""
@@ -30,6 +78,17 @@ class ActivityInfo:
     attempt_number: int
     task_queue: str
     worker_id: str
+    task_metadata: InitVar[Mapping[str, Any] | None] = None
+    retry_info: ActivityRetryInfo = field(init=False)
+    workflow_id: str | None = field(init=False)
+    run_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 {}
+        object.__setattr__(self, "retry_info", ActivityRetryInfo.from_task(self.attempt_number, task))
+        for name in ("workflow_id", "run_id"):
+            value = task.get(name)
+            object.__setattr__(self, name, value if isinstance(value, str) and value else None)
 
 
 class ActivityContext:

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/src/durable_workflow/client.py

@@ -57,6 +57,10 @@ from ._failure_reporting import (
     prepare_failure_request,
 )
 from ._metric_routes import route_for_metrics as _route_for_metrics
+from ._poll_transport import ACCEPT as _POLL_ACCEPT
+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 .errors import (
     REQUEST_ID_CONFLICT,
@@ -1382,6 +1386,10 @@ class WorkflowHandle:
         request_id: str | None = None,
     ) -> dict[str, Any]:
         """Deliver an external signal to this workflow. See :meth:`Client.signal_workflow`."""
+        if self.run_id is not None:
+            return await self._client.signal_workflow(
+                self.workflow_id, signal_name, args=args, request_id=request_id, run_id=self.run_id,
+            )
         return await self._client.signal_workflow(
             self.workflow_id, signal_name, args=args, request_id=request_id,
         )
@@ -1882,6 +1890,7 @@ class Client:
 
         query_poll = worker and path == "/worker/query-tasks/poll"
         activity_poll = worker and path == "/worker/activity-tasks/poll"
+        progress_poll = worker and method.upper() == "POST" and path in _POLL_PATHS
         if query_poll:
             current_query_authority.set(None)
         if activity_poll:
@@ -1931,15 +1940,34 @@ class Client:
             request_timeout = self.timeout if timeout is None else timeout
             if worker and activity_authority is not None and activity_authority.governs(self, self.namespace, path):
                 request_timeout = min(request_timeout, activity_authority.remaining())
-            resp = await self._http.request(
+            headers = self._discovery_headers() if discovery else self._headers(worker=worker)
+            if progress_poll:
+                headers["Accept"] = _POLL_ACCEPT
+            pending = self._http.request(
                 method,
                 f"/api{path}",
-                headers=self._discovery_headers() if discovery else self._headers(worker=worker),
+                headers=headers,
                 json=request_json,
                 timeout=request_timeout,
             )
-            # Raise HTTPStatusError for 4xx/5xx so retry policy can catch it
-            resp.raise_for_status()
+            try:
+                if progress_poll:
+                    try:
+                        resp = await asyncio.wait_for(pending, timeout=request_timeout)
+                    except asyncio.TimeoutError as error:
+                        raise httpx.ReadTimeout(
+                            "Worker poll exceeded its absolute HTTP attempt deadline.",
+                            request=self._http.build_request(method, f"/api{path}"),
+                        ) from error
+                    resp = _unwrap_poll_response(resp)
+                else:
+                    resp = await pending
+                # Interpret negotiated late errors before the usual retry policy.
+                resp.raise_for_status()
+            except (httpx.TransportError, httpx.HTTPStatusError) as error:
+                if progress_poll:
+                    _warn_poll_cutoff(path, request_json, request_started, error)
+                raise
             return resp
 
         try:
@@ -4437,6 +4465,7 @@ class Client:
         *,
         args: list[Any] | None = None,
         request_id: str | None = None,
+        run_id: str | None = None,
     ) -> dict[str, Any]:
         """Deliver an external signal to a running workflow.
 
@@ -4445,12 +4474,18 @@ class Client:
         observe the signal. See the main docs for how to declare the allowed
         signal names on a workflow type.
 
+        Pass ``run_id`` to target the original run. Omitting it targets the
+        current run when the Server receives the request. A run-pinned
+        :class:`WorkflowHandle` forwards its run identity automatically.
+
         ``request_id`` is the caller command key (1-255 opaque, case-sensitive
-        bytes) that makes a retry of this signal safe. When omitted the client
+        bytes). When omitted the client
         generates ``sdk-python-signal-<uuid>`` once per call, so the transport
         retry policy resends the same key. Resending the same key with the same
         signal name, arguments and run target returns the original receipt
-        instead of recording a second signal.
+        only when the runtime supports and applies command-key retention.
+        A runtime without that retention can record repeated signals. Keep
+        business-event processing idempotent and reconcile uncertain delivery.
 
         Returns the Server's admission receipt. ``request_id`` is always
         present (the key that was sent); a Server that retains command keys
@@ -4462,6 +4497,12 @@ class Client:
         in its ``details``. Every exception raised after the key was chosen,
         including transport errors, carries it as ``request_id``.
         """
+        if run_id is not None and (not isinstance(run_id, str) or not run_id):
+            raise ValueError("run_id must be a non-empty string when provided")
+        path = f"/workflows/{quote(workflow_id, safe='')}"
+        if run_id is not None:
+            path += f"/runs/{quote(run_id, safe='')}"
+        path += f"/signal/{quote(signal_name, safe='')}"
         key = _command_request_id(request_id, "signal")
         body: dict[str, Any] = {}
         if args:
@@ -4469,12 +4510,13 @@ class Client:
                 args,
                 kind="signal",
                 workflow_id=workflow_id,
+                run_id=run_id,
                 signal_name=signal_name,
             )
         body["request_id"] = key
         try:
             data = await self._request(
-                "POST", f"/workflows/{workflow_id}/signal/{signal_name}",
+                "POST", path,
                 json=self._with_observability_context(body), context=workflow_id,
             )
         except Exception as exc:

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/src/durable_workflow/sync.py

@@ -535,9 +535,10 @@ class Client:
         *,
         args: list[Any] | None = None,
         request_id: str | None = None,
+        run_id: str | None = None,
     ) -> dict[str, Any]:
         result: dict[str, Any] = self._runner.run(
-            self._async.signal_workflow(workflow_id, signal_name, args=args, request_id=request_id)
+            self._async.signal_workflow(workflow_id, signal_name, args=args, request_id=request_id, run_id=run_id)
         )
         return result
 

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/src/durable_workflow/worker.py

@@ -2105,6 +2105,7 @@ class Worker:
             handler, tuple(call.command.arguments), ActivityInfo(
                 task_id, call.command.activity_type, attempt.attempt_id, attempt.attempt_number,
                 self.task_queue, self.worker_id,
+                task_metadata={"workflow_id": task.get("workflow_id"), "run_id": task.get("run_id")},
             ), {**task, "activity_attempt_id": attempt.attempt_id}, self.interceptors,
             namespace=getattr(self.client, "namespace", None),
             execution_context=telemetry.capture() if telemetry is not None else None,
@@ -2462,6 +2463,7 @@ class Worker:
                     attempt_number=attempt_number,
                     task_queue=self.task_queue,
                     worker_id=self.worker_id,
+                    task_metadata={"workflow_id": task.get("workflow_id"), "run_id": task.get("run_id")},
                 )
                 _set_context(ActivityContext(info=info, client=self.client, heartbeat_callback=heartbeat))
                 try:
@@ -3196,6 +3198,7 @@ class Worker:
                 attempt_number=attempt_number,
                 task_queue=self.task_queue,
                 worker_id=self.worker_id,
+                task_metadata=task,
             ),
             client=self.client,
         )

{durable_workflow-2.11.1 → durable_workflow-2.12.0/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.11.1
+Version: 2.12.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.11.1 → durable_workflow-2.12.0}/src/durable_workflow.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/durable_workflow/_cancellation_scope_history.py
 src/durable_workflow/_cooperative_cancellation.py
 src/durable_workflow/_failure_reporting.py
 src/durable_workflow/_metric_routes.py
+src/durable_workflow/_poll_transport.py
 src/durable_workflow/_prepared_local_activity.py
 src/durable_workflow/_query_task_authority.py
 src/durable_workflow/_sticky_workflow_cache.py
@@ -53,6 +54,7 @@ tests/test_activity_lease_authority.py
 tests/test_activity_lease_renewal.py
 tests/test_activity_lease_worker.py
 tests/test_activity_process.py
+tests/test_activity_retry_info.py
 tests/test_auth_composition.py
 tests/test_avro_value_benchmark.py
 tests/test_avro_value_protocol.py
@@ -104,6 +106,7 @@ tests/test_parallel_saga_authoring.py
 tests/test_patch_history.py
 tests/test_pending_operation_replay.py
 tests/test_poll_failure_backoff.py
+tests/test_poll_transport.py
 tests/test_prepared_local_activity_client.py
 tests/test_prepared_local_activity_groups.py
 tests/test_prepared_local_activity_policies.py

durable_workflow-2.12.0/tests/test_activity_retry_info.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import pickle
+from dataclasses import FrozenInstanceError
+from typing import Any
+
+import pytest
+
+from durable_workflow import ActivityInfo, ActivityRetryInfo, activity
+
+
+@activity.defn(name="context.metadata")
+def inspect_activity_context(_marker: str | None = None) -> dict[str, Any]:
+    info = activity.context().info
+    retry = info.retry_info
+    return {"workflow_id": info.workflow_id, "run_id": info.run_id, "attempt": retry.attempt_number,
+            "policy_provided": retry.policy_provided, "policy": retry.policy(), "maximum": retry.max_attempts(),
+            "unlimited": retry.is_unlimited(), "last": retry.is_last_configured_attempt()}
+
+
+@pytest.mark.parametrize(("attempt", "task", "maximum", "unlimited", "last"), [
+    (1, {"retry_policy": {"max_attempts": 3}}, 3, False, False),
+    (3, {"retry_policy": {"max_attempts": 3}}, 3, False, True),
+    (4, {"retry_policy": {"max_attempts": 3}}, 3, False, True),
+    (1, {"retry_policy": {"max_attempts": 1}}, 1, False, True),
+    (1, {}, None, False, None),
+    (1, {"retry_policy": None}, None, False, None),
+    (99, {"retry_policy": {"max_attempts": None}}, None, True, False),
+    (1, {"retry_policy": {"future": [True, 2.0]}}, None, False, None),
+    (1, {"retry_policy": {"max_attempts": "3"}}, None, False, None),
+    (1, {"retry_policy": {"max_attempts": True}}, None, False, None),
+    (1, {"retry_policy": {"max_attempts": 3.0}}, None, False, None),
+    (1, {"retry_policy": {"max_attempts": 0}}, None, False, None),
+    (1, {"retry_policy": "legacy"}, None, False, None),
+    (0, {"retry_policy": {"max_attempts": 1}}, 1, False, None),
+])
+def test_received_budget_preserves_unknown_and_unlimited(
+    attempt: int, task: dict[str, Any], maximum: int | None, unlimited: bool, last: bool | None,
+) -> None:
+    retry = ActivityRetryInfo.from_task(attempt, task)
+    assert retry.attempt_number == attempt
+    assert retry.policy_provided is ("retry_policy" in task)
+    assert retry.policy() == task.get("retry_policy")
+    assert retry.max_attempts() == maximum
+    assert retry.is_unlimited() is unlimited
+    assert retry.is_last_configured_attempt() is last
+
+
+def test_snapshot_copies_and_original_identity_survive_spawn_serialization() -> None:
+    task = {"workflow_id": "0", "run_id": "017", "retry_policy": {"max_attempts": 3, "future": [True, 2.0, None]}}
+    info = ActivityInfo("task", "activity", "attempt", 3, "queue", "owner", task_metadata=task)
+    task["retry_policy"]["max_attempts"] = 10
+    task["workflow_id"] = "replacement"
+    copy = info.retry_info.policy()
+    copy["future"][0] = False
+    assert info.retry_info.policy() == {"max_attempts": 3, "future": [True, 2.0, None]}
+    assert info.workflow_id == "0" and info.run_id == "017"
+    assert info.retry_info.is_last_configured_attempt() is True
+    restored = pickle.loads(pickle.dumps(info))
+    assert restored == info
+    assert restored.retry_info.policy() == info.retry_info.policy()
+    with pytest.raises(FrozenInstanceError):
+        info.workflow_id = "replacement"  # type: ignore[misc]
+    with pytest.raises(FrozenInstanceError):
+        info.retry_info.attempt_number = 100  # type: ignore[misc]
+
+
+def test_legacy_constructor_has_no_invented_received_policy_or_identity() -> None:
+    info = ActivityInfo("task", "activity", "attempt", 2, "queue", "owner")
+    assert info.retry_info.attempt_number == 2
+    assert info.retry_info.policy_provided is False
+    assert info.retry_info.is_last_configured_attempt() is None
+    assert info.workflow_id is None and info.run_id is None
+
+
+@pytest.mark.parametrize("task", [
+    {}, {"workflow_id": None, "run_id": None}, {"workflow_id": "", "run_id": 42},
+    {"workflow_instance_id": "internal", "workflow_run_id": "internal-run"},
+])
+def test_public_claim_identity_stays_unknown_when_missing_or_invalid(task: dict[str, Any]) -> None:
+    info = ActivityInfo("task", "activity", "attempt", 1, "queue", "owner", task_metadata=task)
+    assert info.workflow_id is None and info.run_id is None

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/tests/test_client.py

@@ -869,6 +869,41 @@ class TestWorkflowHandleControlPlane:
 
 
 class TestSignalWorkflow:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("use_handle", [False, True])
+    async def test_signal_keeps_original_run_and_business_key(self, client: Client, use_handle: bool) -> None:
+        seen = []
+
+        def receive(request: httpx.Request) -> httpx.Response:
+            seen.append(request)
+            return httpx.Response(202, json={"outcome": "received"})
+
+        await client._http.aclose()
+        client._http = httpx.AsyncClient(base_url=client.base_url, transport=httpx.MockTransport(receive))
+        async with client:
+            if use_handle:
+                handle = client.get_workflow_handle("invoice-42", run_id="original-run")
+                await handle.signal("payment_recorded", ["payment-17"], request_id="payment:17")
+            else:
+                await client.signal_workflow("invoice-42", "payment_recorded", args=["payment-17"],
+                                             run_id="original-run", request_id="payment:17")
+        assert len(seen) == 1
+        assert seen[0].url.path == "/api/workflows/invoice-42/runs/original-run/signal/payment_recorded"
+        body = json.loads(seen[0].content)
+        assert body["request_id"] == "payment:17"
+        assert serializer.decode_envelope(body["input"]) == ["payment-17"]
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("run_id", ["", False, 1])
+    async def test_invalid_run_pin_never_falls_back_to_current(self, client: Client, run_id: Any) -> None:
+        with (
+            patch.object(client._http, "request", new_callable=AsyncMock) as request,
+            pytest.raises(ValueError, match="run_id"),
+        ):
+            await client.signal_workflow("invoice-42", "payment_recorded", run_id=run_id)
+        request.assert_not_awaited()
+        await client.aclose()
+
     @pytest.mark.asyncio
     async def test_signal(self, client: Client) -> None:
         resp = _mock_response(200, {"ok": True})

{durable_workflow-2.11.1 → durable_workflow-2.12.0}/tests/test_cooperative_remote_worker.py

@@ -19,6 +19,7 @@ from durable_workflow.errors import ActivityCancelled, NonRetryableError, Server
 from durable_workflow.retry_policy import TransportRetryPolicy
 from durable_workflow.worker import Worker
 from tests.test_activity_process import wait_for_exit, wait_for_file
+from tests.test_activity_retry_info import inspect_activity_context
 from tests.test_worker import compatible_cluster_info
 
 
@@ -205,6 +206,25 @@ async def test_authored_heartbeat_stays_on_owner_loop_and_preserves_typed_result
     client.fail_activity_task.assert_not_awaited()
 
 
+@pytest.mark.parametrize("configured", [False, True])
+async def test_supervised_worker_preserves_received_context(owner: Any, configured: bool) -> None:
+    worker, client = owner
+    worker.activities["remote"] = inspect_activity_context
+    work = task()
+    if configured:
+        work.update(attempt_number=3, workflow_id="0", run_id="017",
+                    retry_policy={"max_attempts": 3, "future": [True, None]})
+    assert await worker._run_activity_task(work) == "completed"
+    client.fail_activity_task.assert_not_awaited()
+    assert client.complete_activity_task.await_args.kwargs["result"] == {
+        "workflow_id": "0" if configured else None, "run_id": "017" if configured else None,
+        "attempt": 3 if configured else 1, "policy_provided": configured,
+        "policy": {"max_attempts": 3, "future": [True, None]} if configured else None,
+        "maximum": 3 if configured else None, "unlimited": False, "last": True if configured else None,
+    }
+    assert not worker._remote_activity_processes
+
+
 @pytest.mark.parametrize("field", ["lease", "heartbeat", "start_to_close", "schedule_to_close", "session", "malformed"])
 async def test_invalid_or_elapsed_observed_bounds_prevent_callback_start(owner: Any, field: str) -> None:
     worker, client = owner