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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.6.1
+Version: 2.7.0
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.27
 Requires-Dist: fastavro<2,>=1.12.2
+Provides-Extra: telemetry
+Requires-Dist: opentelemetry-api<2,>=1.45.1; extra == "telemetry"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
@@ -29,6 +31,7 @@ Requires-Dist: playwright<2,>=1.48; extra == "dev"
 Requires-Dist: PyYAML>=6.0; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: tomli>=2; python_version < "3.11" and extra == "dev"
+Requires-Dist: opentelemetry-sdk==1.45.1; extra == "dev"
 Provides-Extra: prometheus
 Requires-Dist: prometheus-client>=0.20; extra == "prometheus"
 Provides-Extra: docs

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.6.1"
+version = "2.7.0"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -38,6 +38,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+telemetry = [
+    "opentelemetry-api>=1.45.1,<2",
+]
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
@@ -46,6 +49,7 @@ dev = [
     "PyYAML>=6.0",
     "ruff>=0.4",
     "tomli>=2; python_version < '3.11'",
+    "opentelemetry-sdk==1.45.1",
 ]
 prometheus = [
     "prometheus-client>=0.20",
@@ -71,8 +75,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.7.0"
+registry-version = "2.7.0"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.6.1 → durable_workflow-2.7.0}/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.7.0}/src/durable_workflow/_activity_process.py

@@ -40,6 +40,10 @@ class CallbackInvocation:
     info: ActivityInfo
     task: dict[str, Any]
     interceptors: tuple[WorkerInterceptor, ...] = ()
+    namespace: str | None = None
+    observability_supported: bool = False
+    remote: bool = False
+    execution_context: dict[str, Any] | None = None
 
     def serialize(self) -> bytes:
         try:
@@ -100,6 +104,8 @@ def _callback(directory: str, channel: socket.socket) -> None:
         context = ActivityInterceptorContext(
             worker_id=invocation.info.worker_id, task_queue=invocation.info.task_queue,
             task=invocation.task, activity_type=invocation.info.activity_type, args=invocation.args,
+            namespace=invocation.namespace, observability_supported=invocation.observability_supported,
+            remote=invocation.remote, execution_context=invocation.execution_context,
         )
 
         async def call(ctx: ActivityInterceptorContext) -> Any:

{durable_workflow-2.6.1 → durable_workflow-2.7.0}/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.7.0}/src/durable_workflow/client.py

@@ -19,6 +19,7 @@ methods without repeating the id on every call.
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import copy
 import hashlib
 import json as json_module
@@ -47,6 +48,7 @@ from ._cancellation_scope_history import (
 from ._cooperative_cancellation import CancellationDelivery, CancellationRequest
 from ._query_task_authority import QueryTaskAuthority, current_query_authority
 from .errors import (
+    REQUEST_ID_CONFLICT,
     ExternalPayloadIntegrityMismatch,
     ExternalPayloadOversized,
     ExternalPayloadUnavailable,
@@ -55,6 +57,8 @@ from .errors import (
     RuntimeCapabilityUnsupported,
     RuntimeDiscoveryUnavailable,
     ServerError,
+    SignalFailed,
+    UpdateFailed,
     WorkflowCancelled,
     WorkflowFailed,
     WorkflowTerminated,
@@ -71,6 +75,8 @@ from .external_storage import (
 from .metrics import CLIENT_REQUEST_DURATION_SECONDS, CLIENT_REQUESTS, NOOP_METRICS, MetricsRecorder
 from .nexus import NexusOperationResult, nexus_request_payload
 from .retry_policy import TransportRetryPolicy
+from .telemetry import ExecutionTelemetry, current_execution_telemetry
+from .telemetry_carrier import supported as observability_supported
 from .worker_session import WorkerSessionOptions
 
 PROTOCOL_VERSION = "1.20"
@@ -239,6 +245,49 @@ def _normalize_base_url(base_url: str) -> str:
     return base_url.rstrip("/")
 
 
+def _command_request_id(request_id: str | None, command: str) -> str:
+    """Return the caller command key for one logical signal or update call.
+
+    The key is the body field ``request_id`` (1-255 opaque, case-sensitive
+    bytes). A caller-supplied key is sent verbatim; otherwise one
+    ``sdk-python-<command>-<uuid4 hex>`` key is generated per logical call so
+    the transport retry policy resends the identical key.
+    """
+    return request_id or f"sdk-python-{command}-{uuid.uuid4().hex}"
+
+
+def _attach_request_id(exc: BaseException, request_id: str) -> None:
+    """Record the sent command key on an exception as ``exc.request_id``.
+
+    Typed SDK failures declare the attribute; transport errors raised by
+    ``httpx`` receive it dynamically so a manual retry can reuse the key.
+    """
+    with contextlib.suppress(AttributeError, TypeError):
+        exc.request_id = request_id  # type: ignore[attr-defined]
+
+
+def _command_request_failure(exc: Exception, *, command: str, request_id: str) -> Exception:
+    """Return the exception a failed signal or update call should raise.
+
+    A ``request_id_conflict`` refusal that reached the caller as a generic
+    :class:`ServerError` becomes the command's typed failure. Every other
+    exception is returned unchanged, annotated with the key that was sent.
+    """
+    if isinstance(exc, ServerError) and exc.reason() == REQUEST_ID_CONFLICT:
+        message = exc.body.get("message") if isinstance(exc.body, dict) else None
+        if not isinstance(message, str) or not message:
+            message = f"{command} request id already retained with a different intent"
+        if command == "update" and isinstance(exc.body, dict):
+            return UpdateFailed(
+                message, status=exc.status, body=exc.body, reason=REQUEST_ID_CONFLICT, request_id=request_id,
+            )
+        return SignalFailed(
+            message, reason=REQUEST_ID_CONFLICT, status=exc.status, body=exc.body, request_id=request_id,
+        )
+    _attach_request_id(exc, request_id)
+    return exc
+
+
 def _route_for_metrics(path: str) -> str:
     clean_path = path.split("?", 1)[0]
     parts = [part for part in clean_path.strip("/").split("/") if part]
@@ -1346,9 +1395,17 @@ 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 signal(self, signal_name: str, args: list[Any] | None = None) -> None:
+    async def signal(
+        self,
+        signal_name: str,
+        args: list[Any] | None = None,
+        *,
+        request_id: str | None = None,
+    ) -> dict[str, Any]:
         """Deliver an external signal to this workflow. See :meth:`Client.signal_workflow`."""
-        await self._client.signal_workflow(self.workflow_id, signal_name, args=args)
+        return await self._client.signal_workflow(
+            self.workflow_id, signal_name, args=args, request_id=request_id,
+        )
 
     async def append_message(
         self,
@@ -1592,12 +1649,15 @@ class Client:
         external_storage: ExternalStorageDriver | None = None,
         external_storage_threshold_bytes: int | None = None,
         external_storage_cache: ExternalPayloadCache | None = None,
+        telemetry: ExecutionTelemetry | None = None,
     ) -> None:
         self.base_url = _normalize_base_url(base_url)
         self.token = token
         self.control_token = control_token
         self.worker_token = worker_token
         self.namespace = namespace
+        self.telemetry = telemetry
+        self._observability_capability = False
         self.timeout = timeout
         self.retry_policy = retry_policy or TransportRetryPolicy()
         self.metrics = metrics or NOOP_METRICS
@@ -2603,6 +2663,7 @@ class Client:
         credential. Other client methods continue to require the credential
         for their own protocol plane.
         """
+        self._observability_capability = False
         result = await self._request("GET", "/cluster/info", discovery=True, context="get_cluster_info")
         if not isinstance(result, dict):
             raise ServerError(
@@ -2610,8 +2671,16 @@ class Client:
                 {"reason": "invalid_cluster_info", "message": f"expected JSON object, got {type(result).__name__}"},
             )
         self._cluster_info = result
+        self._observability_capability = observability_supported(result)
         return result
 
+    def _with_observability_context(self, body: dict[str, Any]) -> dict[str, Any]:
+        telemetry = self.telemetry or current_execution_telemetry()
+        if telemetry is None or not self._observability_capability:
+            return body
+        carrier = telemetry.capture()
+        return body if carrier is None else {**body, "observability_context": carrier}
+
     async def _runtime_discovery(
         self,
         *,
@@ -2783,6 +2852,7 @@ class Client:
         # provider credentials. The worker keeps using the original client.
         scoped.worker_token = None
         scoped._cluster_info = None
+        scoped._observability_capability = False
         scoped._cluster_info_lock = asyncio.Lock()
         scoped._runtime_external_payload_transport_cache = None
         scoped._runtime_external_payload_transport_resolved = False
@@ -3599,7 +3669,9 @@ class Client:
             body["build_id"] = build_id
         if compatibility is not None:
             body["compatibility"] = compatibility
-        data = await self._request("POST", "/workflows", json=body, context=workflow_id)
+        data = await self._request(
+            "POST", "/workflows", json=self._with_observability_context(body), context=workflow_id,
+        )
         return WorkflowHandle(
             self,
             workflow_id=data["workflow_id"],
@@ -4303,15 +4375,38 @@ class Client:
         return BridgeAdapterOutcome.from_dict(data)
 
     async def signal_workflow(
-        self, workflow_id: str, signal_name: str, *, args: list[Any] | None = None
-    ) -> None:
+        self,
+        workflow_id: str,
+        signal_name: str,
+        *,
+        args: list[Any] | None = None,
+        request_id: str | None = None,
+    ) -> dict[str, Any]:
         """Deliver an external signal to a running workflow.
 
         Signals are fire-and-forget: the server records the signal in durable
         history and returns immediately. They do not wait for the workflow to
         observe the signal. See the main docs for how to declare the allowed
         signal names on a workflow type.
+
+        ``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
+        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.
+
+        Returns the Server's admission receipt. ``request_id`` is always
+        present (the key that was sent); a Server that retains command keys
+        also reports ``retained`` (``True`` when an earlier admission was
+        returned) and ``intent_verified``. Raises
+        :class:`~durable_workflow.errors.SignalFailed` with
+        ``reason == "request_id_conflict"`` when the key was already retained
+        for a signal with a different intent; the retained command is described
+        in its ``details``. Every exception raised after the key was chosen,
+        including transport errors, carries it as ``request_id``.
         """
+        key = _command_request_id(request_id, "signal")
         body: dict[str, Any] = {}
         if args:
             body["input"] = self._payload_envelope(
@@ -4320,7 +4415,20 @@ class Client:
                 workflow_id=workflow_id,
                 signal_name=signal_name,
             )
-        await self._request("POST", f"/workflows/{workflow_id}/signal/{signal_name}", json=body, context=workflow_id)
+        body["request_id"] = key
+        try:
+            data = await self._request(
+                "POST", f"/workflows/{workflow_id}/signal/{signal_name}",
+                json=self._with_observability_context(body), context=workflow_id,
+            )
+        except Exception as exc:
+            failure = _command_request_failure(exc, command="signal", request_id=key)
+            if failure is exc:
+                raise
+            raise failure from exc
+        receipt: dict[str, Any] = data if isinstance(data, dict) else {}
+        receipt.setdefault("request_id", key)
+        return receipt
 
     async def append_message_stream(
         self,
@@ -4430,7 +4538,10 @@ class Client:
         body: dict[str, Any] = {}
         if reason is not None:
             body["reason"] = reason
-        await self._request("POST", f"/workflows/{workflow_id}/cancel", json=body, context=workflow_id)
+        await self._request(
+            "POST", f"/workflows/{workflow_id}/cancel",
+            json=self._with_observability_context(body), context=workflow_id,
+        )
 
     async def terminate_workflow(self, workflow_id: str, *, reason: str | None = None) -> None:
         """Close the current run as terminated immediately.
@@ -4496,15 +4607,28 @@ class Client:
         Validator rejection and validation-routing failures remain typed and
         do not silently fall back to post-accept handler failure.
 
-        ``request_id`` lets the caller deduplicate retries. Raises
-        :class:`~durable_workflow.errors.UpdateRejected` when the workflow's
-        validator rejects the update, or
+        ``request_id`` is the caller command key (1-255 opaque, case-sensitive
+        bytes) that makes a retry of this update safe. When omitted the client
+        generates ``sdk-python-update-<uuid>`` once per call, so the transport
+        retry policy resends the same key. Resending the same key with the same
+        update name, arguments and run target returns the original receipt
+        (``retained`` is ``True`` on a Server that reports it) instead of
+        admitting a second update. The returned response always carries the
+        ``request_id`` that was sent.
+
+        Raises :class:`~durable_workflow.errors.UpdateRejected` when the
+        workflow's validator rejects the update, or
         :class:`~durable_workflow.errors.UpdateValidationFailed` when the
         declared validation boundary cannot be enforced. An accepted update
         whose handler fails raises :class:`~durable_workflow.errors.UpdateFailed`
-        with the failure message, Server response and durable identities.
+        with the failure message, Server response and durable identities; the
+        same type with ``reason == "request_id_conflict"`` reports a key that
+        was already retained for an update with a different intent, described
+        in its ``details``. Every exception raised after the key was chosen,
+        including transport errors, carries it as ``request_id``.
         """
         await self._require_update_wait_stage(wait_for or "accepted")
+        key = _command_request_id(request_id, "update")
         body: dict[str, Any] = {}
         if args:
             body["input"] = self._payload_envelope(
@@ -4517,10 +4641,20 @@ class Client:
             body["wait_for"] = wait_for
         if wait_timeout_seconds is not None:
             body["wait_timeout_seconds"] = wait_timeout_seconds
-        body["request_id"] = request_id or f"sdk-python-update-{uuid.uuid4().hex}"
-        return await self._request(
-            "POST", f"/workflows/{workflow_id}/update/{update_name}", json=body, context=workflow_id
-        )
+        body["request_id"] = key
+        try:
+            data = await self._request(
+                "POST", f"/workflows/{workflow_id}/update/{update_name}",
+                json=self._with_observability_context(body), context=workflow_id,
+            )
+        except Exception as exc:
+            failure = _command_request_failure(exc, command="update", request_id=key)
+            if failure is exc:
+                raise
+            raise failure from exc
+        if isinstance(data, dict):
+            data.setdefault("request_id", key)
+        return data
 
     async def get_result(
         self,
@@ -5291,7 +5425,11 @@ class Client:
         body: dict[str, Any] = {
             "lease_owner": lease_owner,
             "workflow_task_attempt": workflow_task_attempt,
-            "commands": commands,
+            "commands": [
+                self._with_observability_context(command)
+                if command.get("type") in {"start_child_workflow", "continue_as_new"} else command
+                for command in commands
+            ] if self._observability_capability else commands,
         }
         if message_stream_cursors:
             body["message_stream_cursors"] = message_stream_cursors
@@ -5312,15 +5450,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.7.0}/src/durable_workflow/errors.py

@@ -412,8 +412,45 @@ class QueryFailed(DurableWorkflowError):
         return None
 
 
+REQUEST_ID_CONFLICT = "request_id_conflict"
+"""Reason reported when a command key is reused with a different intent."""
+
+_REQUEST_ID_CONFLICT_FIELDS = (
+    "request_id",
+    "retained_command_id",
+    "retained_command_type",
+    "retained_outcome",
+    "conflict",
+)
+
+
+def _body_string(body: object, name: str) -> str | None:
+    if isinstance(body, dict):
+        value = body.get(name)
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+def _request_id_conflict_details(body: object) -> dict[str, Any]:
+    """Return the retained-command fields of a ``request_id_conflict`` response body."""
+    if not isinstance(body, dict) or body.get("reason") != REQUEST_ID_CONFLICT:
+        return {}
+    return {name: body[name] for name in _REQUEST_ID_CONFLICT_FIELDS if name in body}
+
+
 class SignalFailed(DurableWorkflowError):
-    """A workflow signal was rejected before it could be delivered."""
+    """A workflow signal was rejected before it could be delivered.
+
+    :attr:`request_id` is the caller command key the client sent with the
+    signal (caller-supplied or SDK-generated), so the application can retry
+    the same logical signal with the same key. :attr:`reason` is the Server's
+    machine-readable refusal reason; ``request_id_conflict`` means the key was
+    already retained for a signal with a different intent, and
+    :attr:`details` then carries ``retained_command_id``,
+    ``retained_command_type``, ``retained_outcome`` and the mismatched
+    ``conflict`` parts.
+    """
 
     def __init__(
         self,
@@ -422,11 +459,15 @@ class SignalFailed(DurableWorkflowError):
         reason: str | None = None,
         status: int | None = None,
         body: object | None = None,
+        request_id: str | None = None,
+        details: dict[str, Any] | None = None,
     ) -> None:
         super().__init__(message)
         self.reason = reason
         self.status = status
         self.body = body
+        self.request_id = request_id if request_id is not None else _body_string(body, "request_id")
+        self.details: dict[str, Any] = dict(details) if details is not None else _request_id_conflict_details(body)
 
     @property
     def validation_errors(self) -> dict[str, Any] | None:
@@ -465,6 +506,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."""
 
@@ -493,17 +549,37 @@ class NonDeterministicReplayError(DurableWorkflowError):
 
 
 class UpdateFailed(InvalidArgument):
-    """An accepted workflow update failed during handler execution.
+    """An accepted workflow update failed, or its command key was refused.
 
     ``body`` preserves the Server response, including its durable failure
     identity. This inherits from :class:`InvalidArgument` to preserve catches
     written for earlier SDK versions that mapped all HTTP 422 responses there.
+
+    :attr:`request_id` is the caller command key the client sent with the
+    update (caller-supplied or SDK-generated). :attr:`reason` is the Server's
+    machine-readable reason when it returned one; ``request_id_conflict``
+    means the key was already retained for an update with a different intent,
+    and :attr:`details` then carries ``retained_command_id``,
+    ``retained_command_type``, ``retained_outcome`` and the mismatched
+    ``conflict`` parts.
     """
 
-    def __init__(self, message: str, *, status: int, body: dict[str, Any]) -> None:
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        body: dict[str, Any],
+        reason: str | None = None,
+        request_id: str | None = None,
+        details: dict[str, Any] | None = None,
+    ) -> None:
         super().__init__(message)
         self.status = status
         self.body = body
+        self.reason = reason if reason is not None else self._identity(body, "reason")
+        self.request_id = request_id if request_id is not None else self._identity(body, "request_id")
+        self.details: dict[str, Any] = dict(details) if details is not None else _request_id_conflict_details(body)
         self.workflow_id = self._identity(body, "workflow_id")
         self.run_id = self._identity(body, "run_id")
         self.update_id = self._identity(body, "update_id")
@@ -894,6 +970,18 @@ def _raise_for_status(status: int, body: object, *, context: str = "") -> None:
             raise UpdateRejected(message or "update rejected", body=body)
         if reason in update_validation_failure_reasons:
             raise update_validation_failed("update validation failed")
+        if reason == REQUEST_ID_CONFLICT:
+            # The retained command type names the key scope; the Server also
+            # labels the control-plane operation. Either selects the typed failure.
+            command_type = _body_string(body, "retained_command_type") or operation
+            if command_type == "signal":
+                raise signal_failed("signal request id already retained with a different intent")
+            if command_type == "update" and isinstance(body, dict):
+                raise UpdateFailed(
+                    message or "update request id already retained with a different intent",
+                    status=status,
+                    body=body,
+                )
         raise ServerError(status, body)
 
     if status == 504:

{durable_workflow-2.6.1 → durable_workflow-2.7.0}/src/durable_workflow/interceptors.py

@@ -14,6 +14,9 @@ class WorkflowTaskInterceptorContext:
     worker_id: str
     task_queue: str
     task: dict[str, Any]
+    namespace: str | None = None
+    observability_supported: bool = False
+    defer_observability: bool = False
 
 
 @dataclass(frozen=True)
@@ -25,6 +28,10 @@ class ActivityInterceptorContext:
     task: dict[str, Any]
     activity_type: str
     args: tuple[Any, ...]
+    namespace: str | None = None
+    observability_supported: bool = False
+    remote: bool = False
+    execution_context: dict[str, Any] | None = None
 
 
 @dataclass(frozen=True)
@@ -34,6 +41,8 @@ class QueryTaskInterceptorContext:
     worker_id: str
     task_queue: str
     task: dict[str, Any]
+    namespace: str | None = None
+    observability_supported: bool = False
 
 
 WorkflowTaskHandler = Callable[[WorkflowTaskInterceptorContext], Awaitable[list[dict[str, Any]] | None]]