aws-durable-execution-sdk-python 2.0.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

aws_durable_execution_sdk_python/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "2.0.1"
+__version__ = "3.0.0"

aws_durable_execution_sdk_python/concurrency/executor.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextvars
 import heapq
 import logging
 import queue
@@ -44,7 +45,7 @@ from aws_durable_execution_sdk_python.identifier import (
     OperationIdentifier,
     OperationIdNamespace,
 )
-from aws_durable_execution_sdk_python.lambda_service import ErrorObject
+from aws_durable_execution_sdk_python.lambda_service import ErrorObject, OperationType
 from aws_durable_execution_sdk_python.operation.child import child_handler
 
 
@@ -52,7 +53,6 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from aws_durable_execution_sdk_python.config import CompletionConfig
     from aws_durable_execution_sdk_python.context import DurableContext
-    from aws_durable_execution_sdk_python.lambda_service import OperationSubType
     from aws_durable_execution_sdk_python.serdes import SerDes
     from aws_durable_execution_sdk_python.state import (
         CheckpointedResult,
@@ -128,8 +128,8 @@ class ConcurrentExecutor(Generic[CallableType, ResultType]):
         executables: list[Executable[CallableType]],
         max_concurrency: int | None,
         completion_config: CompletionConfig,
-        sub_type_top: OperationSubType,
-        sub_type_iteration: OperationSubType,
+        sub_type_top: str,
+        sub_type_iteration: str,
         name_prefix: str,
         serdes: SerDes | None,
         operation_id_namespace: OperationIdNamespace,
@@ -183,6 +183,7 @@ class ConcurrentExecutor(Generic[CallableType, ResultType]):
                 executable.index
             ),
             sub_type=self.sub_type_iteration,
+            operation_type=OperationType.CONTEXT,
             parent_id=executor_context._parent_id,  # noqa: SLF001
             name=self.get_iteration_name(executable.index),
         )
@@ -291,13 +292,25 @@ class ConcurrentExecutor(Generic[CallableType, ResultType]):
 
         def submit(branch: Branch[CallableType, ResultType]) -> None:
             branch.start()
-            pool.submit(
-                self._branch_worker,
-                execution_state,
-                executor_context,
-                events,
-                branch.executable,
-            )
+            if execution_state._plugin_executor._plugins:  # noqa: SLF001
+                # Every admission/resume gets its own Context. Branch bindings
+                # cannot leak into siblings, the coordinator, or reused workers.
+                pool.submit(
+                    contextvars.copy_context().run,
+                    self._branch_worker,
+                    execution_state,
+                    executor_context,
+                    events,
+                    branch.executable,
+                )
+            else:
+                pool.submit(
+                    self._branch_worker,
+                    execution_state,
+                    executor_context,
+                    events,
+                    branch.executable,
+                )
 
         try:
             # Only rebuild the items snapshot after a terminal event changes
@@ -688,7 +701,6 @@ class ConcurrentExecutor(Generic[CallableType, ResultType]):
             operation_identifier=operation_identifier,
             config=ChildConfig(
                 serdes=self.item_serdes or self.serdes,
-                sub_type=self.sub_type_iteration,
                 is_virtual=is_virtual,
             ),
         )

aws_durable_execution_sdk_python/concurrency/models.py

@@ -7,7 +7,7 @@ import logging
 from collections import Counter
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Generic, TypeVar
+from typing import TYPE_CHECKING, Generic, TypeVar, cast
 
 from aws_durable_execution_sdk_python.exceptions import (
     ChildContextError,
@@ -396,6 +396,12 @@ def envelope_summary_generator(
 
 @dataclass(frozen=True)
 class BatchItem(Generic[R]):
+    """One branch of a map or parallel batch.
+
+    ``error`` may be None on a FAILED item when its source contained no
+    ErrorObject. ``BatchResult.throw_if_error`` still raises for it.
+    """
+
     index: int
     status: BatchItemStatus
     result: R | None = None
@@ -489,18 +495,10 @@ class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
         }
 
     def succeeded(self) -> list[BatchItem[R]]:
-        return [
-            item
-            for item in self.all
-            if item.status is BatchItemStatus.SUCCEEDED and item.result is not None
-        ]
+        return [item for item in self.all if item.status is BatchItemStatus.SUCCEEDED]
 
     def failed(self) -> list[BatchItem[R]]:
-        return [
-            item
-            for item in self.all
-            if item.status is BatchItemStatus.FAILED and item.error is not None
-        ]
+        return [item for item in self.all if item.status is BatchItemStatus.FAILED]
 
     def started(self) -> list[BatchItem[R]]:
         return [item for item in self.all if item.status is BatchItemStatus.STARTED]
@@ -518,32 +516,44 @@ class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
         return any(item.status is BatchItemStatus.FAILED for item in self.all)
 
     def throw_if_error(self) -> None:
-        first_error = next(
-            (item.error for item in self.all if item.status is BatchItemStatus.FAILED),
+        first_failed = next(
+            (item for item in self.all if item.status is BatchItemStatus.FAILED),
             None,
         )
-        if first_error is not None:
+        if first_failed is not None:
+            first_error = first_failed.error
+            if first_error is None:
+                raise ChildContextError(
+                    message=(
+                        f"Batch item {first_failed.index} failed "
+                        "without an ErrorObject."
+                    )
+                )
+
             # Each item runs in a child context, so a failed item surfaces as a
             # ChildContextError wrapping the escaping error (reconstructed as its
             # typed form where possible, with __cause__ set). Remaining errors
             # stay in get_errors().
             first_error.raise_as_operation_error(ChildContextError)
         if self.completion_reason is CompletionReason.CUSTOM_COMPLETION_FAILED:
-            # A custom decision marked the batch failed with no item error.
+            # A custom decision marked the batch failed with no failed item.
             raise BatchCompletionError(self.completion_reason)
 
     def get_results(self) -> list[R]:
+        # None is a valid result for a branch that returns nothing.
         return [
-            item.result
+            cast(R, item.result)
             for item in self.all
-            if item.status is BatchItemStatus.SUCCEEDED and item.result is not None
+            if item.status is BatchItemStatus.SUCCEEDED
         ]
 
-    def get_errors(self) -> list[ErrorObject]:
+    def get_errors(self) -> list[ErrorObject | None]:
+        """Return one entry per FAILED item, in branch order.
+
+        An entry is None when the corresponding item has no ErrorObject.
+        """
         return [
-            item.error
-            for item in self.all
-            if item.status is BatchItemStatus.FAILED and item.error is not None
+            item.error for item in self.all if item.status is BatchItemStatus.FAILED
         ]
 
     @property

aws_durable_execution_sdk_python/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import math
 import random
+import string
 from dataclasses import dataclass, field
 from enum import Enum, StrEnum
 from typing import TYPE_CHECKING, Generic, TypeVar
@@ -18,7 +19,6 @@ T = TypeVar("T")
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aws_durable_execution_sdk_python.lambda_service import OperationSubType
     from aws_durable_execution_sdk_python.retries import RetryDecision
     from aws_durable_execution_sdk_python.serdes import SerDes
     from aws_durable_execution_sdk_python.types import SummaryGenerator
@@ -481,13 +481,69 @@ class StepSemantics(Enum):
     AT_LEAST_ONCE_PER_RETRY = "AT_LEAST_ONCE_PER_RETRY"
 
 
+_SUB_TYPE_CHARACTERS = frozenset(string.ascii_letters + string.digits + "-_")
+_SUB_TYPE_MAX_LENGTH = 32
+
+
+def _validate_sub_type(sub_type: str | None) -> None:
+    """Raise ValidationError when sub_type is set and the service would reject it.
+
+    The service accepts 1 to 32 characters from A-Z, a-z, 0-9, hyphen, and
+    underscore. None and "" select the SDK default, so both are accepted.
+    Checking here raises before any checkpoint is sent, so a step body never
+    runs under a subtype the service will reject.
+    """
+    if not sub_type:
+        return
+    if (
+        len(sub_type) > _SUB_TYPE_MAX_LENGTH
+        or not set(sub_type) <= _SUB_TYPE_CHARACTERS
+    ):
+        msg = (
+            f"sub_type must be 1 to {_SUB_TYPE_MAX_LENGTH} characters from "
+            f"A-Z, a-z, 0-9, hyphen, and underscore, got: {sub_type!r}"
+        )
+        raise ValidationError(msg)
+
+
 @dataclass(frozen=True)
 class StepConfig:
-    """Configuration for a step."""
+    """Configuration for a step.
+
+    Args:
+        retry_strategy: Decides whether and when a failed attempt is retried.
+            If None, the SDK uses its default retry strategy.
+
+        step_semantics: How often one attempt may run the function.
+            AT_LEAST_ONCE_PER_RETRY (the default) checkpoints START without
+            waiting, so an interrupted attempt runs again on the next
+            invocation. AT_MOST_ONCE_PER_RETRY waits for the START checkpoint
+            first, and an interrupted attempt fails with StepInterruptedError
+            and goes to the retry strategy instead of running again.
+
+        serdes: Custom serialization/deserialization for the step result.
+            If None, uses the default JSON serializer.
+
+        sub_type: Subtype recorded in the checkpoint, in replay validation, and
+            in plugin events. The default is "Step".
+            A custom operation built from steps uses this to label its steps,
+            so history and plugins can filter them without parsing names.
+            The value must be 1 to 32 characters from A-Z, a-z, 0-9, hyphen,
+            and underscore; the config raises ValidationError otherwise. None
+            or an empty string selects the default. Do not reuse an
+            ``OperationSubType`` value: those label the SDK's own operations.
+            Replay compares the subtype with the checkpoint. So changing the
+            subtype of an existing step is a breaking change for executions
+            in flight.
+    """
 
     retry_strategy: Callable[[Exception, int], RetryDecision] | None = None
     step_semantics: StepSemantics = StepSemantics.AT_LEAST_ONCE_PER_RETRY
     serdes: SerDes | None = None
+    sub_type: str | None = field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        _validate_sub_type(self.sub_type)
 
 
 @dataclass(frozen=True)
@@ -502,9 +558,18 @@ class ChildConfig(Generic[T]):
             Applied at the handler level to serialize the entire BatchResult object.
             If None, uses the default JSON serializer for BatchResult.
 
-        sub_type: Operation subtype identifier used for tracking and debugging.
-            Examples: OperationSubType.MAP_ITERATION, OperationSubType.PARALLEL_BRANCH.
-            Used internally by the execution engine for operation classification.
+        sub_type: Subtype recorded in the checkpoint, in replay validation, and
+            in plugin events. The default is "RunInChildContext".
+            A custom operation built from several durable operations uses this
+            to label its child context, so history and plugins can filter it
+            without parsing names. The value must be 1 to 32 characters from
+            A-Z, a-z, 0-9, hyphen, and underscore; the config raises
+            ValidationError otherwise. None or an empty string selects the
+            default. Do not reuse an ``OperationSubType`` value: those label
+            the SDK's own operations.
+            Replay compares the subtype with the checkpoint. So changing the
+            subtype of an existing child context is a breaking change for
+            executions in flight.
 
         summary_generator: Function generating the checkpoint payload for large
             results (>256KB). When the serialized result exceeds CHECKPOINT_SIZE_LIMIT,
@@ -528,10 +593,13 @@ class ChildConfig(Generic[T]):
     """
 
     serdes: SerDes | None = None
-    sub_type: OperationSubType | None = None
+    sub_type: str | None = None
     summary_generator: SummaryGenerator | None = None
     is_virtual: bool = False
 
+    def __post_init__(self) -> None:
+        _validate_sub_type(self.sub_type)
+
 
 @dataclass(frozen=True)
 class MapConfig(Generic[T]):
@@ -649,11 +717,45 @@ class InvokeConfig(Generic[P, R]):
 
 @dataclass(frozen=True)
 class CallbackConfig:
-    """Configuration for callbacks."""
+    """Configuration for callbacks.
+
+    Args:
+        timeout: Maximum time to wait for the callback result. The default,
+            a zero Duration, means no timeout.
+
+        heartbeat_timeout: Maximum time between heartbeats before the callback
+            fails. The default, a zero Duration, means no heartbeat timeout.
+
+        serdes: Custom deserialization for the callback result.
+            If None, the payload is returned as is, without JSON parsing.
+
+        sub_type: Subtype recorded in the checkpoint, in replay validation, and
+            in plugin events. The default is "Callback".
+            A custom operation built from callbacks uses this to label its
+            callbacks, so history and plugins can filter them without parsing
+            names. The value must be 1 to 32 characters from A-Z, a-z, 0-9,
+            hyphen, and underscore; the config raises ValidationError
+            otherwise. None or an empty string selects the default. Do not
+            reuse an ``OperationSubType`` value: those label the SDK's own
+            operations. Under
+            ``wait_for_callback`` the subtype labels the callback the
+            operation creates; the surrounding context keeps the subtype
+            "WaitForCallback".
+            Replay compares the subtype with the checkpoint. So changing the
+            subtype of an existing callback is a breaking change for
+            executions in flight.
+    """
 
     timeout: Duration = field(default_factory=Duration)
     heartbeat_timeout: Duration = field(default_factory=Duration)
     serdes: SerDes | None = None
+    # Keyword-only, so the positional order of every config, including
+    # WaitForCallbackConfig(timeout, heartbeat_timeout, serdes, retry_strategy),
+    # is unchanged from 2.x.
+    sub_type: str | None = field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        _validate_sub_type(self.sub_type)
 
     @property
     def timeout_seconds(self) -> int:

aws_durable_execution_sdk_python/context.py

@@ -51,7 +51,10 @@ from aws_durable_execution_sdk_python.operation.callback import (
     CallbackOperationExecutor,
     wait_for_callback_handler,
 )
-from aws_durable_execution_sdk_python.operation.child import child_handler
+from aws_durable_execution_sdk_python.operation.child import (
+    ChildOperationExecutor,
+    child_handler,
+)
 from aws_durable_execution_sdk_python.operation.invoke import InvokeOperationExecutor
 from aws_durable_execution_sdk_python.operation.map import map_handler
 from aws_durable_execution_sdk_python.operation.parallel import parallel_handler
@@ -506,8 +509,15 @@ class DurableContext(DurableContextProtocol):
         )
 
     def _peek_next_checkpoint(self) -> CheckpointedResult:
-        """Return the checkpoint for this context's next operation, without consuming it."""
-        return self.state.get_checkpoint_result(self._peek_next_operation_id())
+        """Return the checkpoint for this context's next operation, without consuming it.
+
+        The read takes no plugin end hook: the hook of an operation a
+        checkpoint response completed during this invocation belongs to the
+        read that consumes the result, the operation's own.
+        """
+        return self.state.get_checkpoint_result(
+            self._peek_next_operation_id(), claim_end_hook=False
+        )
 
     def _next_operation_exists(self) -> bool:
         """True if a checkpoint exists for this context's next operation."""
@@ -515,12 +525,18 @@ class DurableContext(DurableContextProtocol):
 
     @contextmanager
     def _replay_aware(
-        self, operation_identifier: OperationIdentifier | None = None
+        self,
+        operation_identifier: OperationIdentifier | None = None,
+        *,
+        is_virtual: bool = False,
     ) -> Iterator[None]:
         """Wrap a single operation with replay-boundary detection.
 
         The operation kind is inferred from its own checkpoint (when one
-        exists), so no per-call-site flag is needed.
+        exists). The one per-call-site input is `is_virtual`: a virtual child
+        context never checkpoints itself, so with `is_virtual=True` any
+        checkpoint at its id is rejected right after the identity check,
+        before replay and update hooks run.
 
         The boundary has these parts:
 
@@ -539,9 +555,14 @@ class DurableContext(DurableContextProtocol):
         # Only look up a checkpoint when replaying. Operation call sites pass
         # their atomically allocated identifier so concurrent callers inspect
         # the checkpoint for their own ID rather than peeking at shared state.
+        # Both reads inspect: neither consumes the result, so neither takes
+        # the plugin end hook a checkpoint response may have recorded for the
+        # operation. The operation's own read, which consumes the result, does.
         next_checkpoint: CheckpointedResult | None = (
             (
-                self.state.get_checkpoint_result(operation_identifier.operation_id)
+                self.state.get_checkpoint_result(
+                    operation_identifier.operation_id, claim_end_hook=False
+                )
                 if operation_identifier is not None
                 else self._peek_next_checkpoint()
             )
@@ -555,6 +576,10 @@ class DurableContext(DurableContextProtocol):
         if was_replaying and next_operation is not None:
             if operation_identifier is not None:
                 operation_identifier.validate_checkpoint(next_operation)
+                if is_virtual:
+                    ChildOperationExecutor.validate_virtual_checkpoint(
+                        operation_identifier, next_operation
+                    )
 
             # While replaying, an operation that already has a checkpoint was
             # observed in a prior invocation. If the backend says the operation
@@ -597,9 +622,11 @@ class DurableContext(DurableContextProtocol):
     @contextmanager
     def _operation_replay_aware(
         self,
-        sub_type: OperationSubType,
+        sub_type: str,
         name: str | None = None,
-        operation_type: OperationType | None = None,
+        *,
+        operation_type: OperationType,
+        is_virtual: bool = False,
     ) -> Iterator[OperationIdentifier]:
         """Allocate an operation and validate its replay identity before hooks."""
         operation_identifier = OperationIdentifier(
@@ -609,7 +636,7 @@ class DurableContext(DurableContextProtocol):
             name=name,
             operation_type=operation_type,
         )
-        with self._replay_aware(operation_identifier):
+        with self._replay_aware(operation_identifier, is_virtual=is_virtual):
             yield operation_identifier
 
     # endregion replay status
@@ -629,14 +656,16 @@ class DurableContext(DurableContextProtocol):
         Args:
             name (str): Optional name for the operation.
             config (CallbackConfig): Configuration for the callback.
+                ``config.sub_type`` labels the operation; see CallbackConfig.
 
         Return:
-            Callback future. Use result() on this future to wait for the callback resuilt.
+            Callback future. Use result() on this future to wait for the callback result.
         """
         if not config:
             config = CallbackConfig()
+        sub_type = config.sub_type or OperationSubType.CALLBACK.value
         with self._operation_replay_aware(
-            OperationSubType.CALLBACK, name
+            sub_type, name, operation_type=OperationType.CALLBACK
         ) as operation_identifier:
             executor: CallbackOperationExecutor = CallbackOperationExecutor(
                 state=self.state,
@@ -672,7 +701,9 @@ class DurableContext(DurableContextProtocol):
         if not config:
             config = InvokeConfig[P, R]()
         with self._operation_replay_aware(
-            OperationSubType.CHAINED_INVOKE, name
+            OperationSubType.CHAINED_INVOKE.value,
+            name,
+            operation_type=OperationType.CHAINED_INVOKE,
         ) as operation_identifier:
             executor: InvokeOperationExecutor[R] = InvokeOperationExecutor(
                 function_name=function_name,
@@ -700,7 +731,7 @@ class DurableContext(DurableContextProtocol):
             config.completion_config._validate_for_total(len(inputs))
 
         with self._operation_replay_aware(
-            OperationSubType.MAP, map_name
+            OperationSubType.MAP.value, map_name, operation_type=OperationType.CONTEXT
         ) as operation_identifier:
             operation_id = operation_identifier.operation_id
             map_context = self.create_child_context(operation_id=operation_id)
@@ -725,7 +756,6 @@ class DurableContext(DurableContextProtocol):
                 state=self.state,
                 operation_identifier=operation_identifier,
                 config=ChildConfig(
-                    sub_type=OperationSubType.MAP,
                     serdes=config.serdes if config else None,
                     # The SDK-owned envelope records the completion decision for
                     # replay. A configured summary_generator only contributes the
@@ -751,7 +781,7 @@ class DurableContext(DurableContextProtocol):
             config.completion_config._validate_for_total(len(functions))
 
         with self._operation_replay_aware(
-            OperationSubType.PARALLEL, name
+            OperationSubType.PARALLEL.value, name, operation_type=OperationType.CONTEXT
         ) as operation_identifier:
             operation_id = operation_identifier.operation_id
             parallel_context = self.create_child_context(operation_id=operation_id)
@@ -775,7 +805,6 @@ class DurableContext(DurableContextProtocol):
                 state=self.state,
                 operation_identifier=operation_identifier,
                 config=ChildConfig(
-                    sub_type=OperationSubType.PARALLEL,
                     serdes=config.serdes if config else None,
                     # The SDK-owned envelope records the completion decision for
                     # replay. A configured summary_generator only contributes the
@@ -798,27 +827,42 @@ class DurableContext(DurableContextProtocol):
         Use this to nest and group operations.
 
         Args:
-            callable (Callable[[DurableContext], T]): Run this callable and pass the child context as the argument to it.
+            func (Callable[[DurableContext], T]): Run this callable and pass the child context as the argument to it.
             name (str | None): name for the operation.
-            config (ChildConfig | None = None): c
+            config (ChildConfig | None = None): Configuration for the child
+                context. ``config.sub_type`` labels the operation; see
+                ChildConfig.
 
         Returns:
             T: The result of the callable.
         """
         step_name: str | None = self._resolve_step_name(name, func)
         sub_type = (
-            config.sub_type
-            if config and config.sub_type
-            else OperationSubType.RUN_IN_CHILD_CONTEXT
-        )
+            config.sub_type if config else None
+        ) or OperationSubType.RUN_IN_CHILD_CONTEXT.value
+        return self._run_in_child_context(func, step_name, config, sub_type)
+
+    def _run_in_child_context(
+        self,
+        func: Callable[[DurableContext], T],
+        step_name: str | None,
+        config: ChildConfig | None,
+        sub_type: str,
+    ) -> T:
+        """Run ``func`` in a child context that records ``sub_type``.
+
+        ``run_in_child_context`` resolves the caller's ``config.sub_type``
+        into ``sub_type``; ``wait_for_callback`` passes its own SDK subtype.
+        """
+        is_virtual: bool = config.is_virtual if config else False
 
         with self._operation_replay_aware(
             sub_type,
             step_name,
             operation_type=OperationType.CONTEXT,
+            is_virtual=is_virtual,
         ) as operation_identifier:
             operation_id = operation_identifier.operation_id
-            is_virtual: bool = config.is_virtual if config else False
 
             def callable_with_child_context():
                 return func(
@@ -840,12 +884,24 @@ class DurableContext(DurableContextProtocol):
         name: str | None = None,
         config: StepConfig | None = None,
     ) -> T:
+        """Run a function once and checkpoint its result.
+
+        Args:
+            func (Callable[[StepContext], T]): The function to run.
+            name (str | None): Optional name for the operation.
+            config (StepConfig | None): Configuration for the step.
+                ``config.sub_type`` labels the operation; see StepConfig.
+
+        Returns:
+            T: The function's result, from the checkpoint on replay.
+        """
         step_name = self._resolve_step_name(name, func)
         logger.debug("Step name: %s", step_name)
         if not config:
             config = StepConfig()
+        sub_type = config.sub_type or OperationSubType.STEP.value
         with self._operation_replay_aware(
-            OperationSubType.STEP, step_name
+            sub_type, step_name, operation_type=OperationType.STEP
         ) as operation_identifier:
             executor: StepOperationExecutor[T] = StepOperationExecutor(
                 func=func,
@@ -868,7 +924,7 @@ class DurableContext(DurableContextProtocol):
             msg = "duration must be at least 1 second"
             raise ValidationError(msg)
         with self._operation_replay_aware(
-            OperationSubType.WAIT, name
+            OperationSubType.WAIT.value, name, operation_type=OperationType.WAIT
         ) as operation_identifier:
             wait_seconds = duration.seconds
             executor: WaitOperationExecutor = WaitOperationExecutor(
@@ -894,10 +950,11 @@ class DurableContext(DurableContextProtocol):
         # inner failure on __cause__; translate to callback-typed errors here, at
         # the call site, so it re-fires identically on replay.
         try:
-            return self.run_in_child_context(
+            return self._run_in_child_context(
                 wait_in_child_context,
                 step_name,
-                ChildConfig(sub_type=OperationSubType.WAIT_FOR_CALLBACK),
+                None,
+                OperationSubType.WAIT_FOR_CALLBACK.value,
             )
         except ChildContextError as e:
             inner: BaseException | None = e.__cause__
@@ -938,7 +995,9 @@ class DurableContext(DurableContextProtocol):
             raise ValidationError(msg)
 
         with self._operation_replay_aware(
-            OperationSubType.WAIT_FOR_CONDITION, name
+            OperationSubType.WAIT_FOR_CONDITION.value,
+            name,
+            operation_type=OperationType.STEP,
         ) as operation_identifier:
             executor: WaitForConditionOperationExecutor[T] = (
                 WaitForConditionOperationExecutor(