durable-workflow 0.4.94__tar.gz → 0.4.96__tar.gz

{durable_workflow-0.4.94/src/durable_workflow.egg-info → durable_workflow-0.4.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 0.4.94
+Version: 0.4.96
 Summary: Python SDK for the Durable Workflow server (language-neutral HTTP protocol)
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -160,6 +160,36 @@ receipt = yield ctx.start_child_workflow(
 )
 ```
 
+## Nexus service calls
+
+Workflow code can call a registered Nexus service operation through
+`WorkflowContext.call_nexus_service(...)`. The worker executes the service
+operation through the service-catalog API, records the response or typed
+failure as a durable side-effect marker, and resumes replay from that marker
+on subsequent workflow tasks.
+
+```python
+from durable_workflow import NexusOperationFailed
+
+try:
+    result = yield ctx.call_nexus_service(
+        "greeter",
+        "shared",
+        "greet",
+        ["Ada"],
+        service_sdk_language="workflow-php",
+    )
+    print(result.service_call_id, result.result)
+except NexusOperationFailed as exc:
+    print(exc.service_call_id, exc.service_error_type, exc.typed_error_message)
+```
+
+The SDK assigns a deterministic idempotency key when one is not provided and
+attaches the caller workflow instance id, caller run id, `sdk-python` caller
+language, target service language, operation name, request payload,
+service-call id, response or failure surface, and optional artifact metadata
+to the recorded result.
+
 ## Workflow signals, queries, and updates
 
 Signals mutate workflow state during replay:

{durable_workflow-0.4.94 → durable_workflow-0.4.96}/README.md

@@ -124,6 +124,36 @@ receipt = yield ctx.start_child_workflow(
 )
 ```
 
+## Nexus service calls
+
+Workflow code can call a registered Nexus service operation through
+`WorkflowContext.call_nexus_service(...)`. The worker executes the service
+operation through the service-catalog API, records the response or typed
+failure as a durable side-effect marker, and resumes replay from that marker
+on subsequent workflow tasks.
+
+```python
+from durable_workflow import NexusOperationFailed
+
+try:
+    result = yield ctx.call_nexus_service(
+        "greeter",
+        "shared",
+        "greet",
+        ["Ada"],
+        service_sdk_language="workflow-php",
+    )
+    print(result.service_call_id, result.result)
+except NexusOperationFailed as exc:
+    print(exc.service_call_id, exc.service_error_type, exc.typed_error_message)
+```
+
+The SDK assigns a deterministic idempotency key when one is not provided and
+attaches the caller workflow instance id, caller run id, `sdk-python` caller
+language, target service language, operation name, request payload,
+service-call id, response or failure surface, and optional artifact metadata
+to the recorded result.
+
 ## Workflow signals, queries, and updates
 
 Signals mutate workflow state during replay:

{durable_workflow-0.4.94 → durable_workflow-0.4.96}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "0.4.94"
+version = "0.4.96"
 description = "Python SDK for the Durable Workflow server (language-neutral HTTP protocol)"
 readme = "README.md"
 requires-python = ">=3.10"

{durable_workflow-0.4.94 → durable_workflow-0.4.96}/src/durable_workflow/__init__.py

@@ -60,6 +60,7 @@ from .errors import (
     DurableWorkflowError,
     InvalidArgument,
     NamespaceNotFound,
+    NexusOperationFailed,
     NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
@@ -76,6 +77,12 @@ from .errors import (
     WorkflowPayloadDecodeError,
     WorkflowTerminated,
 )
+from .nexus import (
+    NEXUS_CALLER_SDK_LANGUAGE,
+    NEXUS_OPERATION_RESULT_SCHEMA,
+    NEXUS_OPERATION_RESULT_VERSION,
+    NexusOperationResult,
+)
 from .external_storage import (
     EXTERNAL_PAYLOAD_REFERENCE_SCHEMA,
     AzureBlobExternalStorage,
@@ -173,6 +180,7 @@ from .workflow import (
     ActivityRetryPolicy,
     ChildWorkflowRetryPolicy,
     ContinueAsNew,
+    NexusServiceCall,
     Replayer,
     ReplayOutcome,
     StartChildWorkflow,
@@ -197,6 +205,9 @@ __all__ = [
     "ContinueAsNew",
     "NamespaceDescription",
     "NamespaceList",
+    "NEXUS_CALLER_SDK_LANGUAGE",
+    "NEXUS_OPERATION_RESULT_SCHEMA",
+    "NEXUS_OPERATION_RESULT_VERSION",
     "AUTH_COMPOSITION_CONTRACT_SCHEMA",
     "AUTH_COMPOSITION_CONTRACT_VERSION",
     "AUTH_COMPOSITION_REQUIRED_EFFECTIVE_CONFIG_FIELDS",
@@ -275,6 +286,9 @@ __all__ = [
     "LocalFilesystemExternalStorage",
     "MetricsRecorder",
     "NamespaceNotFound",
+    "NexusOperationFailed",
+    "NexusOperationResult",
+    "NexusServiceCall",
     "NonDeterministicReplayError",
     "NoopMetrics",
     "QueryFailed",

{durable_workflow-0.4.94 → durable_workflow-0.4.96}/src/durable_workflow/client.py

@@ -24,7 +24,7 @@ import os
 import time
 import uuid
 import warnings
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _pkg_version
@@ -43,6 +43,7 @@ from .errors import (
 )
 from .external_storage import ExternalPayloadCache, ExternalPayloadStoragePolicy, ExternalStorageDriver
 from .metrics import CLIENT_REQUEST_DURATION_SECONDS, CLIENT_REQUESTS, NOOP_METRICS, MetricsRecorder
+from .nexus import NexusOperationResult, nexus_request_payload
 from .retry_policy import TransportRetryPolicy
 
 PROTOCOL_VERSION = "1.1"
@@ -163,6 +164,8 @@ class WorkflowExecution:
     input: Any = None
     output: Any = None
     payload_codec: str | None = None
+    memo: dict[str, Any] | None = None
+    search_attributes: dict[str, Any] | None = None
 
 
 @dataclass
@@ -1563,6 +1566,112 @@ class Client:
         """
         return WorkflowHandle(self, workflow_id=workflow_id, run_id=run_id, workflow_type=workflow_type)
 
+    async def execute_nexus_operation(
+        self,
+        endpoint_name: str,
+        service_name: str,
+        operation_name: str,
+        arguments: Sequence[Any] | None = None,
+        *,
+        mode: str | None = None,
+        wait_for: str | None = None,
+        wait_timeout_seconds: int | None = None,
+        idempotency_key: str | None = None,
+        payload_codec: str | None = None,
+        caller_namespace: str | None = None,
+        caller_workflow_instance_id: str | None = None,
+        caller_workflow_run_id: str | None = None,
+        service_sdk_language: str | None = None,
+        artifact_tuple: Mapping[str, Any] | None = None,
+        published_artifact_worker_execution: bool | None = None,
+        target_workflow_instance_id: str | None = None,
+        target_workflow_run_id: str | None = None,
+        connection: str | None = None,
+        queue: str | None = None,
+        business_key: str | None = None,
+        labels: Mapping[str, Any] | None = None,
+        memo: Mapping[str, Any] | None = None,
+        search_attributes: Mapping[str, Any] | None = None,
+        duplicate_start_policy: str | None = None,
+        raise_on_failure: bool = True,
+    ) -> NexusOperationResult:
+        """Execute a Nexus service operation through the service-catalog API.
+
+        Workflow code should normally yield
+        :meth:`durable_workflow.workflow.WorkflowContext.call_nexus_service`;
+        the worker uses this client method to make the single durable
+        execute request and records the returned service-call surface into
+        workflow history.
+        """
+        request_body = nexus_request_payload(
+            arguments=list(arguments) if arguments is not None else [],
+            payload_codec=payload_codec,
+            mode=mode,
+            wait_for=wait_for,
+            wait_timeout_seconds=wait_timeout_seconds,
+            idempotency_key=idempotency_key,
+            caller_namespace=caller_namespace or self.namespace,
+            caller_workflow_instance_id=caller_workflow_instance_id,
+            caller_workflow_run_id=caller_workflow_run_id,
+            target_workflow_instance_id=target_workflow_instance_id,
+            target_workflow_run_id=target_workflow_run_id,
+            connection=connection,
+            queue=queue,
+            business_key=business_key,
+            labels=labels,
+            memo=memo,
+            search_attributes=search_attributes,
+            duplicate_start_policy=duplicate_start_policy,
+        )
+        path = (
+            f"/service-endpoints/{quote(endpoint_name, safe='')}"
+            f"/services/{quote(service_name, safe='')}"
+            f"/operations/{quote(operation_name, safe='')}/execute"
+        )
+        context = f"{endpoint_name}/{service_name}/{operation_name}"
+
+        try:
+            data = await self._request("POST", path, json=request_body, context=context)
+        except ServerError as exc:
+            if exc.status != 409 or not isinstance(exc.body, dict):
+                raise
+            result = NexusOperationResult.from_response(
+                exc.body,
+                endpoint_name=endpoint_name,
+                service_name=service_name,
+                operation_name=operation_name,
+                request_payload=request_body,
+                service_sdk_language=service_sdk_language,
+                artifact_tuple=artifact_tuple,
+                published_artifact_worker_execution=published_artifact_worker_execution,
+            )
+            if raise_on_failure:
+                raise result.to_failure() from exc
+            return result
+
+        if not isinstance(data, dict):
+            raise ServerError(
+                200,
+                {
+                    "reason": "invalid_nexus_operation_response",
+                    "message": f"expected JSON object, got {type(data).__name__}",
+                },
+            )
+
+        result = NexusOperationResult.from_response(
+            data,
+            endpoint_name=endpoint_name,
+            service_name=service_name,
+            operation_name=operation_name,
+            request_payload=request_body,
+            service_sdk_language=service_sdk_language,
+            artifact_tuple=artifact_tuple,
+            published_artifact_worker_execution=published_artifact_worker_execution,
+        )
+        if raise_on_failure and result.is_failure:
+            raise result.to_failure()
+        return result
+
     # ── Health ─────────────────────────────────────────────────────────
     async def health(self) -> dict[str, Any]:
         """Call the server's ``/health`` endpoint and return the JSON response."""
@@ -2279,6 +2388,10 @@ class Client:
             input=input_val,
             output=output_val,
             payload_codec=data.get("payload_codec"),
+            memo=data.get("memo") if isinstance(data.get("memo"), dict) else None,
+            search_attributes=(
+                data.get("search_attributes") if isinstance(data.get("search_attributes"), dict) else None
+            ),
         )
 
     async def list_workflows(
@@ -2318,6 +2431,13 @@ class Client:
                 run_id=item.get("run_id"),
                 workflow_type=item.get("workflow_type", ""),
                 status=item.get("status"),
+                namespace=item.get("namespace"),
+                task_queue=item.get("task_queue"),
+                payload_codec=item.get("payload_codec"),
+                memo=item.get("memo") if isinstance(item.get("memo"), dict) else None,
+                search_attributes=(
+                    item.get("search_attributes") if isinstance(item.get("search_attributes"), dict) else None
+                ),
             )
             for item in items
         ]

{durable_workflow-0.4.94 → durable_workflow-0.4.96}/src/durable_workflow/errors.py

@@ -44,6 +44,39 @@ class ServerError(DurableWorkflowError):
         return None
 
 
+class NexusOperationFailed(DurableWorkflowError):
+    """A Nexus service operation completed with a typed service failure."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        service_call_id: str | None = None,
+        endpoint_name: str | None = None,
+        service_name: str | None = None,
+        operation_name: str | None = None,
+        status: str | None = None,
+        outcome: str | None = None,
+        reason: str | None = None,
+        service_error_type: str | None = None,
+        caller_observed_error_type: str | None = None,
+        typed_error_message: str | None = None,
+        body: object | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.service_call_id = service_call_id
+        self.endpoint_name = endpoint_name
+        self.service_name = service_name
+        self.operation_name = operation_name
+        self.status = status
+        self.outcome = outcome
+        self.reason = reason
+        self.service_error_type = service_error_type
+        self.caller_observed_error_type = caller_observed_error_type
+        self.typed_error_message = typed_error_message
+        self.body = body
+
+
 class WorkflowFailed(DurableWorkflowError):
     """A workflow finished in the ``failed`` state.
 

durable_workflow-0.4.96/src/durable_workflow/nexus.py

@@ -0,0 +1,307 @@
+"""Nexus service-operation request and replay result helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import NexusOperationFailed
+
+NEXUS_OPERATION_RESULT_SCHEMA = "durable-workflow.v2.sdk-python.nexus-operation-result"
+NEXUS_OPERATION_RESULT_VERSION = 1
+NEXUS_CALLER_SDK_LANGUAGE = "sdk-python"
+
+_FAILURE_STATUSES = {"failed", "cancelled", "canceled", "timed_out", "timeout"}
+_FAILURE_OUTCOMES = {
+    "failed",
+    "handler_failed",
+    "cancelled",
+    "canceled",
+    "timed_out",
+    "timeout",
+    "dispatch_failed",
+    "handler_unavailable",
+    "worker_unavailable",
+}
+
+
+def _optional_str(value: Any) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _json_default(value: Any) -> str:
+    return str(value)
+
+
+def _clean_dict(values: Mapping[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def stable_nexus_idempotency_key(
+    *,
+    workflow_id: str,
+    run_id: str,
+    ordinal: int,
+    endpoint_name: str,
+    service_name: str,
+    operation_name: str,
+    arguments: Sequence[Any],
+) -> str:
+    """Return a deterministic idempotency key for one workflow-side Nexus call."""
+    source = {
+        "schema": "durable-workflow.v2.sdk-python.nexus-idempotency-key",
+        "workflow_id": workflow_id,
+        "run_id": run_id,
+        "ordinal": ordinal,
+        "endpoint_name": endpoint_name,
+        "service_name": service_name,
+        "operation_name": operation_name,
+        "arguments": list(arguments),
+    }
+    encoded = json.dumps(source, sort_keys=True, separators=(",", ":"), default=_json_default)
+    return f"dw-py-nexus-{hashlib.sha256(encoded.encode()).hexdigest()}"
+
+
+def nexus_request_payload(
+    *,
+    arguments: Sequence[Any],
+    payload_codec: str | None = None,
+    mode: str | None = None,
+    wait_for: str | None = None,
+    wait_timeout_seconds: int | None = None,
+    idempotency_key: str | None = None,
+    caller_namespace: str | None = None,
+    caller_workflow_instance_id: str | None = None,
+    caller_workflow_run_id: str | None = None,
+    target_workflow_instance_id: str | None = None,
+    target_workflow_run_id: str | None = None,
+    connection: str | None = None,
+    queue: str | None = None,
+    business_key: str | None = None,
+    labels: Mapping[str, Any] | None = None,
+    memo: Mapping[str, Any] | None = None,
+    search_attributes: Mapping[str, Any] | None = None,
+    duplicate_start_policy: str | None = None,
+) -> dict[str, Any]:
+    """Build the server execute-operation request body."""
+    return _clean_dict({
+        "arguments": list(arguments),
+        "payload_codec": payload_codec,
+        "mode_override": mode,
+        "wait_for": wait_for,
+        "wait_timeout_seconds": wait_timeout_seconds,
+        "idempotency_key": idempotency_key,
+        "caller_namespace": caller_namespace,
+        "caller_workflow_instance_id": caller_workflow_instance_id,
+        "caller_workflow_run_id": caller_workflow_run_id,
+        "target_workflow_instance_id": target_workflow_instance_id,
+        "target_workflow_run_id": target_workflow_run_id,
+        "connection": connection,
+        "queue": queue,
+        "business_key": business_key,
+        "labels": dict(labels) if labels is not None else None,
+        "memo": dict(memo) if memo is not None else None,
+        "search_attributes": dict(search_attributes) if search_attributes is not None else None,
+        "duplicate_start_policy": duplicate_start_policy,
+    })
+
+
+@dataclass(frozen=True)
+class NexusOperationResult:
+    """Durable result recorded for a Nexus service operation."""
+
+    accepted: bool
+    service_call_id: str
+    endpoint_name: str
+    service_name: str
+    operation_name: str
+    caller_workflow_instance_id: str | None = None
+    caller_workflow_run_id: str | None = None
+    caller_sdk_language: str = NEXUS_CALLER_SDK_LANGUAGE
+    service_sdk_language: str | None = None
+    request_payload: dict[str, Any] = field(default_factory=dict)
+    response_or_failure_surface: dict[str, Any] = field(default_factory=dict)
+    artifact_tuple: dict[str, Any] | None = None
+    published_artifact_worker_execution: bool | None = None
+    status: str | None = None
+    outcome: str | None = None
+    reason: str | None = None
+    message: str | None = None
+    service_error_type: str | None = None
+    caller_observed_error_type: str | None = None
+    typed_error_message: str | None = None
+    result: Any = None
+
+    @classmethod
+    def from_response(
+        cls,
+        data: Mapping[str, Any],
+        *,
+        endpoint_name: str,
+        service_name: str,
+        operation_name: str,
+        request_payload: Mapping[str, Any],
+        service_sdk_language: str | None = None,
+        artifact_tuple: Mapping[str, Any] | None = None,
+        published_artifact_worker_execution: bool | None = None,
+    ) -> NexusOperationResult:
+        call = data.get("service_call")
+        source = call if isinstance(call, Mapping) else data
+        service_call_id = (
+            _optional_str(source.get("service_call_id"))
+            or _optional_str(source.get("id"))
+            or _optional_str(data.get("service_call_id"))
+            or _optional_str(data.get("id"))
+            or ""
+        )
+        accepted = data.get("accepted", source.get("accepted", True)) is not False
+        raw = dict(data)
+        response_value = source.get("result", data.get("result"))
+        return cls(
+            accepted=accepted,
+            service_call_id=service_call_id,
+            endpoint_name=endpoint_name,
+            service_name=service_name,
+            operation_name=_optional_str(source.get("operation_name")) or operation_name,
+            caller_workflow_instance_id=_optional_str(source.get("caller_workflow_instance_id"))
+            or _optional_str(data.get("caller_workflow_instance_id"))
+            or _optional_str(request_payload.get("caller_workflow_instance_id")),
+            caller_workflow_run_id=_optional_str(source.get("caller_workflow_run_id"))
+            or _optional_str(data.get("caller_workflow_run_id"))
+            or _optional_str(request_payload.get("caller_workflow_run_id")),
+            service_sdk_language=service_sdk_language,
+            request_payload=dict(request_payload),
+            response_or_failure_surface=raw,
+            artifact_tuple=dict(artifact_tuple) if artifact_tuple is not None else None,
+            published_artifact_worker_execution=published_artifact_worker_execution,
+            status=_optional_str(source.get("status")) or _optional_str(data.get("status")),
+            outcome=_optional_str(data.get("outcome")) or _optional_str(source.get("outcome")),
+            reason=_optional_str(data.get("reason")) or _optional_str(source.get("reason")),
+            message=_optional_str(data.get("message")) or _optional_str(source.get("message")),
+            service_error_type=_optional_str(source.get("service_error_type"))
+            or _optional_str(data.get("service_error_type")),
+            caller_observed_error_type=_optional_str(source.get("caller_observed_error_type"))
+            or _optional_str(data.get("caller_observed_error_type")),
+            typed_error_message=_optional_str(source.get("typed_error_message"))
+            or _optional_str(data.get("typed_error_message")),
+            result=response_value,
+        )
+
+    @classmethod
+    def from_recorded_payload(cls, value: Any, *, expected: Mapping[str, Any]) -> NexusOperationResult:
+        if not isinstance(value, Mapping):
+            raise ValueError("recorded Nexus operation result must be a mapping")
+        if value.get("schema") != NEXUS_OPERATION_RESULT_SCHEMA:
+            raise ValueError("recorded Nexus operation result schema is not recognized")
+        if value.get("version") != NEXUS_OPERATION_RESULT_VERSION:
+            raise ValueError("recorded Nexus operation result version is not supported")
+
+        for key in ("endpoint_name", "service_name", "operation_name", "idempotency_key"):
+            expected_value = expected.get(key)
+            recorded_value = value.get(key)
+            if expected_value is not None and recorded_value is not None and expected_value != recorded_value:
+                raise ValueError(
+                    f"recorded Nexus operation {key} {recorded_value!r} does not match current "
+                    f"workflow command {expected_value!r}"
+                )
+
+        response_surface = value.get("response_or_failure_surface")
+        request_payload = value.get("request_payload")
+        artifact_tuple = value.get("artifact_tuple")
+        result = cls(
+            accepted=value.get("accepted") is not False,
+            service_call_id=str(value.get("service_call_id") or ""),
+            endpoint_name=str(value.get("endpoint_name") or expected.get("endpoint_name") or ""),
+            service_name=str(value.get("service_name") or expected.get("service_name") or ""),
+            operation_name=str(value.get("operation_name") or expected.get("operation_name") or ""),
+            caller_workflow_instance_id=_optional_str(value.get("caller_workflow_instance_id")),
+            caller_workflow_run_id=_optional_str(value.get("caller_workflow_run_id")),
+            caller_sdk_language=str(value.get("caller_sdk_language") or NEXUS_CALLER_SDK_LANGUAGE),
+            service_sdk_language=_optional_str(value.get("service_sdk_language")),
+            request_payload=dict(request_payload) if isinstance(request_payload, Mapping) else {},
+            response_or_failure_surface=dict(response_surface) if isinstance(response_surface, Mapping) else {},
+            artifact_tuple=dict(artifact_tuple) if isinstance(artifact_tuple, Mapping) else None,
+            published_artifact_worker_execution=value.get("published_artifact_worker_execution")
+            if isinstance(value.get("published_artifact_worker_execution"), bool)
+            else None,
+            status=_optional_str(value.get("status")),
+            outcome=_optional_str(value.get("outcome")),
+            reason=_optional_str(value.get("reason")),
+            message=_optional_str(value.get("message")),
+            service_error_type=_optional_str(value.get("service_error_type")),
+            caller_observed_error_type=_optional_str(value.get("caller_observed_error_type")),
+            typed_error_message=_optional_str(value.get("typed_error_message")),
+            result=value.get("result"),
+        )
+        if result.is_failure:
+            raise result.to_failure()
+        return result
+
+    @property
+    def is_failure(self) -> bool:
+        status = (self.status or "").lower()
+        outcome = (self.outcome or "").lower()
+        return (
+            not self.accepted
+            or status in _FAILURE_STATUSES
+            or outcome in _FAILURE_OUTCOMES
+            or outcome.startswith("rejected")
+            or self.service_error_type is not None
+            or self.caller_observed_error_type is not None
+            or self.typed_error_message is not None
+        )
+
+    def to_failure(self) -> NexusOperationFailed:
+        message = (
+            self.typed_error_message
+            or self.message
+            or self.reason
+            or self.outcome
+            or self.status
+            or "Nexus service operation failed"
+        )
+        return NexusOperationFailed(
+            message,
+            service_call_id=self.service_call_id or None,
+            endpoint_name=self.endpoint_name,
+            service_name=self.service_name,
+            operation_name=self.operation_name,
+            status=self.status,
+            outcome=self.outcome,
+            reason=self.reason,
+            service_error_type=self.service_error_type,
+            caller_observed_error_type=self.caller_observed_error_type,
+            typed_error_message=self.typed_error_message,
+            body=self.response_or_failure_surface,
+        )
+
+    def to_recorded_payload(self) -> dict[str, Any]:
+        return _clean_dict({
+            "schema": NEXUS_OPERATION_RESULT_SCHEMA,
+            "version": NEXUS_OPERATION_RESULT_VERSION,
+            "accepted": self.accepted,
+            "service_call_id": self.service_call_id,
+            "endpoint_name": self.endpoint_name,
+            "service_name": self.service_name,
+            "operation_name": self.operation_name,
+            "idempotency_key": self.request_payload.get("idempotency_key"),
+            "caller_workflow_instance_id": self.caller_workflow_instance_id,
+            "caller_workflow_run_id": self.caller_workflow_run_id,
+            "caller_sdk_language": self.caller_sdk_language,
+            "service_sdk_language": self.service_sdk_language,
+            "request_payload": self.request_payload,
+            "response_or_failure_surface": self.response_or_failure_surface,
+            "artifact_tuple": self.artifact_tuple,
+            "published_artifact_worker_execution": self.published_artifact_worker_execution,
+            "status": self.status,
+            "outcome": self.outcome,
+            "reason": self.reason,
+            "message": self.message,
+            "service_error_type": self.service_error_type,
+            "caller_observed_error_type": self.caller_observed_error_type,
+            "typed_error_message": self.typed_error_message,
+            "result": self.result,
+        })