durabletask 0.1.0a1__py3-none-any.whl → 1.0.0__py3-none-any.whl

durabletask/__init__.py

@@ -3,5 +3,8 @@
 
 """Durable Task SDK for Python"""
 
+from durabletask.worker import ConcurrencyOptions, VersioningOptions
+
+__all__ = ["ConcurrencyOptions", "VersioningOptions"]
 
 PACKAGE_NAME = "durabletask"

durabletask/client.py

@@ -4,18 +4,20 @@
 import logging
 import uuid
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, TypeVar, Union
+from typing import Any, Optional, Sequence, TypeVar, Union
 
 import grpc
 from google.protobuf import wrappers_pb2
 
+from durabletask.entities import EntityInstanceId
 import durabletask.internal.helpers as helpers
 import durabletask.internal.orchestrator_service_pb2 as pb
 import durabletask.internal.orchestrator_service_pb2_grpc as stubs
 import durabletask.internal.shared as shared
 from durabletask import task
+from durabletask.internal.grpc_interceptor import DefaultClientInterceptorImpl
 
 TInput = TypeVar('TInput')
 TOutput = TypeVar('TOutput')
@@ -42,10 +44,10 @@ class OrchestrationState:
     runtime_status: OrchestrationStatus
     created_at: datetime
     last_updated_at: datetime
-    serialized_input: Union[str, None]
-    serialized_output: Union[str, None]
-    serialized_custom_status: Union[str, None]
-    failure_details: Union[task.FailureDetails, None]
+    serialized_input: Optional[str]
+    serialized_output: Optional[str]
+    serialized_custom_status: Optional[str]
+    failure_details: Optional[task.FailureDetails]
 
     def raise_if_failed(self):
         if self.failure_details is not None:
@@ -64,7 +66,7 @@ class OrchestrationFailedError(Exception):
         return self._failure_details
 
 
-def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Union[OrchestrationState, None]:
+def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Optional[OrchestrationState]:
     if not res.exists:
         return None
 
@@ -92,39 +94,66 @@ def new_orchestration_state(instance_id: str, res: pb.GetInstanceResponse) -> Un
 class TaskHubGrpcClient:
 
     def __init__(self, *,
-                 host_address: Union[str, None] = None,
-                 log_handler=None,
-                 log_formatter: Union[logging.Formatter, None] = None):
-        channel = shared.get_grpc_channel(host_address)
+                 host_address: Optional[str] = None,
+                 metadata: Optional[list[tuple[str, str]]] = None,
+                 log_handler: Optional[logging.Handler] = None,
+                 log_formatter: Optional[logging.Formatter] = None,
+                 secure_channel: bool = False,
+                 interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
+                 default_version: Optional[str] = None):
+
+        # If the caller provided metadata, we need to create a new interceptor for it and
+        # add it to the list of interceptors.
+        if interceptors is not None:
+            interceptors = list(interceptors)
+            if metadata is not None:
+                interceptors.append(DefaultClientInterceptorImpl(metadata))
+        elif metadata is not None:
+            interceptors = [DefaultClientInterceptorImpl(metadata)]
+        else:
+            interceptors = None
+
+        channel = shared.get_grpc_channel(
+            host_address=host_address,
+            secure_channel=secure_channel,
+            interceptors=interceptors
+        )
         self._stub = stubs.TaskHubSidecarServiceStub(channel)
-        self._logger = shared.get_logger(log_handler, log_formatter)
+        self._logger = shared.get_logger("client", log_handler, log_formatter)
+        self.default_version = default_version
 
     def schedule_new_orchestration(self, orchestrator: Union[task.Orchestrator[TInput, TOutput], str], *,
-                                   input: Union[TInput, None] = None,
-                                   instance_id: Union[str, None] = None,
-                                   start_at: Union[datetime, None] = None) -> str:
+                                   input: Optional[TInput] = None,
+                                   instance_id: Optional[str] = None,
+                                   start_at: Optional[datetime] = None,
+                                   reuse_id_policy: Optional[pb.OrchestrationIdReusePolicy] = None,
+                                   tags: Optional[dict[str, str]] = None,
+                                   version: Optional[str] = None) -> str:
 
         name = orchestrator if isinstance(orchestrator, str) else task.get_name(orchestrator)
 
         req = pb.CreateInstanceRequest(
             name=name,
             instanceId=instance_id if instance_id else uuid.uuid4().hex,
-            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input else None,
+            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input is not None else None,
             scheduledStartTimestamp=helpers.new_timestamp(start_at) if start_at else None,
-            version=wrappers_pb2.StringValue(value=""))
+            version=helpers.get_string_value(version if version else self.default_version),
+            orchestrationIdReusePolicy=reuse_id_policy,
+            tags=tags
+        )
 
         self._logger.info(f"Starting new '{name}' instance with ID = '{req.instanceId}'.")
         res: pb.CreateInstanceResponse = self._stub.StartInstance(req)
         return res.instanceId
 
-    def get_orchestration_state(self, instance_id: str, *, fetch_payloads: bool = True) -> Union[OrchestrationState, None]:
+    def get_orchestration_state(self, instance_id: str, *, fetch_payloads: bool = True) -> Optional[OrchestrationState]:
         req = pb.GetInstanceRequest(instanceId=instance_id, getInputsAndOutputs=fetch_payloads)
         res: pb.GetInstanceResponse = self._stub.GetInstance(req)
         return new_orchestration_state(req.instanceId, res)
 
     def wait_for_orchestration_start(self, instance_id: str, *,
                                      fetch_payloads: bool = False,
-                                     timeout: int = 60) -> Union[OrchestrationState, None]:
+                                     timeout: int = 60) -> Optional[OrchestrationState]:
         req = pb.GetInstanceRequest(instanceId=instance_id, getInputsAndOutputs=fetch_payloads)
         try:
             self._logger.info(f"Waiting up to {timeout}s for instance '{instance_id}' to start.")
@@ -139,12 +168,24 @@ class TaskHubGrpcClient:
 
     def wait_for_orchestration_completion(self, instance_id: str, *,
                                           fetch_payloads: bool = True,
-                                          timeout: int = 60) -> Union[OrchestrationState, None]:
+                                          timeout: int = 60) -> Optional[OrchestrationState]:
         req = pb.GetInstanceRequest(instanceId=instance_id, getInputsAndOutputs=fetch_payloads)
         try:
             self._logger.info(f"Waiting {timeout}s for instance '{instance_id}' to complete.")
             res: pb.GetInstanceResponse = self._stub.WaitForInstanceCompletion(req, timeout=timeout)
-            return new_orchestration_state(req.instanceId, res)
+            state = new_orchestration_state(req.instanceId, res)
+            if not state:
+                return None
+
+            if state.runtime_status == OrchestrationStatus.FAILED and state.failure_details is not None:
+                details = state.failure_details
+                self._logger.info(f"Instance '{instance_id}' failed: [{details.error_type}] {details.message}")
+            elif state.runtime_status == OrchestrationStatus.TERMINATED:
+                self._logger.info(f"Instance '{instance_id}' was terminated.")
+            elif state.runtime_status == OrchestrationStatus.COMPLETED:
+                self._logger.info(f"Instance '{instance_id}' completed.")
+
+            return state
         except grpc.RpcError as rpc_error:
             if rpc_error.code() == grpc.StatusCode.DEADLINE_EXCEEDED:  # type: ignore
                 # Replace gRPC error with the built-in TimeoutError
@@ -153,7 +194,7 @@ class TaskHubGrpcClient:
                 raise
 
     def raise_orchestration_event(self, instance_id: str, event_name: str, *,
-                                  data: Union[Any, None] = None):
+                                  data: Optional[Any] = None):
         req = pb.RaiseEventRequest(
             instanceId=instance_id,
             name=event_name,
@@ -163,10 +204,12 @@ class TaskHubGrpcClient:
         self._stub.RaiseEvent(req)
 
     def terminate_orchestration(self, instance_id: str, *,
-                                output: Union[Any, None] = None):
+                                output: Optional[Any] = None,
+                                recursive: bool = True):
         req = pb.TerminateRequest(
             instanceId=instance_id,
-            output=wrappers_pb2.StringValue(value=shared.to_json(output)) if output else None)
+            output=wrappers_pb2.StringValue(value=shared.to_json(output)) if output else None,
+            recursive=recursive)
 
         self._logger.info(f"Terminating instance '{instance_id}'.")
         self._stub.TerminateInstance(req)
@@ -180,3 +223,21 @@ class TaskHubGrpcClient:
         req = pb.ResumeRequest(instanceId=instance_id)
         self._logger.info(f"Resuming instance '{instance_id}'.")
         self._stub.ResumeInstance(req)
+
+    def purge_orchestration(self, instance_id: str, recursive: bool = True):
+        req = pb.PurgeInstancesRequest(instanceId=instance_id, recursive=recursive)
+        self._logger.info(f"Purging instance '{instance_id}'.")
+        self._stub.PurgeInstances(req)
+
+    def signal_entity(self, entity_instance_id: EntityInstanceId, operation_name: str, input: Optional[Any] = None):
+        req = pb.SignalEntityRequest(
+            instanceId=str(entity_instance_id),
+            name=operation_name,
+            input=wrappers_pb2.StringValue(value=shared.to_json(input)) if input else None,
+            requestId=str(uuid.uuid4()),
+            scheduledTime=None,
+            parentTraceContext=None,
+            requestTime=helpers.new_timestamp(datetime.now(timezone.utc))
+        )
+        self._logger.info(f"Signaling entity '{entity_instance_id}' operation '{operation_name}'.")
+        self._stub.SignalEntity(req, None)  # TODO: Cancellation timeout?

durabletask/entities/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Durable Task SDK for Python entities component"""
+
+from durabletask.entities.entity_instance_id import EntityInstanceId
+from durabletask.entities.durable_entity import DurableEntity
+from durabletask.entities.entity_lock import EntityLock
+from durabletask.entities.entity_context import EntityContext
+
+__all__ = ["EntityInstanceId", "DurableEntity", "EntityLock", "EntityContext"]
+
+PACKAGE_NAME = "durabletask.entities"

durabletask/entities/durable_entity.py

@@ -0,0 +1,93 @@
+from typing import Any, Optional, Type, TypeVar, Union, overload
+
+from durabletask.entities.entity_context import EntityContext
+from durabletask.entities.entity_instance_id import EntityInstanceId
+
+TState = TypeVar("TState")
+
+
+class DurableEntity:
+    def _initialize_entity_context(self, context: EntityContext):
+        self.entity_context = context
+
+    @overload
+    def get_state(self, intended_type: Type[TState], default: TState) -> TState:
+        ...
+
+    @overload
+    def get_state(self, intended_type: Type[TState]) -> Optional[TState]:
+        ...
+
+    @overload
+    def get_state(self, intended_type: None = None, default: Any = None) -> Any:
+        ...
+
+    def get_state(self, intended_type: Optional[Type[TState]] = None, default: Optional[TState] = None) -> Union[None, TState, Any]:
+        """Get the current state of the entity, optionally converting it to a specified type.
+
+        Parameters
+        ----------
+        intended_type : Type[TState] | None, optional
+            The type to which the state should be converted. If None, the state is returned as-is.
+        default : TState, optional
+            The default value to return if the state is not found or cannot be converted.
+
+        Returns
+        -------
+        TState | Any
+            The current state of the entity, optionally converted to the specified type.
+        """
+        return self.entity_context.get_state(intended_type, default)
+
+    def set_state(self, state: Any):
+        """Set the state of the entity to a new value.
+
+        Parameters
+        ----------
+        new_state : Any
+            The new state to set for the entity.
+        """
+        self.entity_context.set_state(state)
+
+    def signal_entity(self, entity_instance_id: EntityInstanceId, operation: str, input: Optional[Any] = None) -> None:
+        """Signal another entity to perform an operation.
+
+        Parameters
+        ----------
+        entity_instance_id : EntityInstanceId
+            The ID of the entity instance to signal.
+        operation : str
+            The operation to perform on the entity.
+        input : Any, optional
+            The input to provide to the entity for the operation.
+        """
+        self.entity_context.signal_entity(entity_instance_id, operation, input)
+
+    def schedule_new_orchestration(self, orchestration_name: str, input: Optional[Any] = None, instance_id: Optional[str] = None) -> str:
+        """Schedule a new orchestration instance.
+
+        Parameters
+        ----------
+        orchestration_name : str
+            The name of the orchestration to schedule.
+        input : Any, optional
+            The input to provide to the new orchestration.
+        instance_id : str, optional
+            The instance ID to assign to the new orchestration. If None, a new ID will be generated.
+
+        Returns
+        -------
+        str
+            The instance ID of the scheduled orchestration.
+        """
+        return self.entity_context.schedule_new_orchestration(orchestration_name, input, instance_id=instance_id)
+
+    def delete(self, input: Any = None) -> None:
+        """Delete the entity instance.
+
+        Parameters
+        ----------
+        input : Any, optional
+            Unused: The input for the entity "delete" operation.
+        """
+        self.set_state(None)

durabletask/entities/entity_context.py

@@ -0,0 +1,154 @@
+
+from typing import Any, Optional, Type, TypeVar, Union, overload
+import uuid
+from durabletask.entities.entity_instance_id import EntityInstanceId
+from durabletask.internal import helpers, shared
+from durabletask.internal.entity_state_shim import StateShim
+import durabletask.internal.orchestrator_service_pb2 as pb
+
+TState = TypeVar("TState")
+
+
+class EntityContext:
+    def __init__(self, orchestration_id: str, operation: str, state: StateShim, entity_id: EntityInstanceId):
+        self._orchestration_id = orchestration_id
+        self._operation = operation
+        self._state = state
+        self._entity_id = entity_id
+
+    @property
+    def orchestration_id(self) -> str:
+        """Get the ID of the orchestration instance that scheduled this entity.
+
+        Returns
+        -------
+        str
+            The ID of the current orchestration instance.
+        """
+        return self._orchestration_id
+
+    @property
+    def operation(self) -> str:
+        """Get the operation associated with this entity invocation.
+
+        The operation is a string that identifies the specific action being
+        performed on the entity. It can be used to distinguish between
+        multiple operations that are part of the same entity invocation.
+
+        Returns
+        -------
+        str
+            The operation associated with this entity invocation.
+        """
+        return self._operation
+
+    @overload
+    def get_state(self, intended_type: Type[TState], default: TState) -> TState:
+        ...
+
+    @overload
+    def get_state(self, intended_type: Type[TState]) -> Optional[TState]:
+        ...
+
+    @overload
+    def get_state(self, intended_type: None = None, default: Any = None) -> Any:
+        ...
+
+    def get_state(self, intended_type: Optional[Type[TState]] = None, default: Optional[TState] = None) -> Union[None, TState, Any]:
+        """Get the current state of the entity, optionally converting it to a specified type.
+
+        Parameters
+        ----------
+        intended_type : Type[TState] | None, optional
+            The type to which the state should be converted. If None, the state is returned as-is.
+        default : TState, optional
+            The default value to return if the state is not found or cannot be converted.
+
+        Returns
+        -------
+        TState | Any
+            The current state of the entity, optionally converted to the specified type.
+        """
+        return self._state.get_state(intended_type, default)
+
+    def set_state(self, new_state: Any):
+        """Set the state of the entity to a new value.
+
+        Parameters
+        ----------
+        new_state : Any
+            The new state to set for the entity.
+        """
+        self._state.set_state(new_state)
+
+    def signal_entity(self, entity_instance_id: EntityInstanceId, operation: str, input: Optional[Any] = None) -> None:
+        """Signal another entity to perform an operation.
+
+        Parameters
+        ----------
+        entity_instance_id : EntityInstanceId
+            The ID of the entity instance to signal.
+        operation : str
+            The operation to perform on the entity.
+        input : Any, optional
+            The input to provide to the entity for the operation.
+        """
+        encoded_input = shared.to_json(input) if input is not None else None
+        self._state.add_operation_action(
+            pb.OperationAction(
+                sendSignal=pb.SendSignalAction(
+                    instanceId=str(entity_instance_id),
+                    name=operation,
+                    input=helpers.get_string_value(encoded_input),
+                    scheduledTime=None,
+                    requestTime=None,
+                    parentTraceContext=None,
+                )
+            )
+        )
+
+    def schedule_new_orchestration(self, orchestration_name: str, input: Optional[Any] = None, instance_id: Optional[str] = None) -> str:
+        """Schedule a new orchestration instance.
+
+        Parameters
+        ----------
+        orchestration_name : str
+            The name of the orchestration to schedule.
+        input : Any, optional
+            The input to provide to the new orchestration.
+        instance_id : str, optional
+            The instance ID to assign to the new orchestration. If None, a new ID will be generated.
+
+        Returns
+        -------
+        str
+            The instance ID of the scheduled orchestration.
+        """
+        encoded_input = shared.to_json(input) if input is not None else None
+        if not instance_id:
+            instance_id = uuid.uuid4().hex
+        self._state.add_operation_action(
+            pb.OperationAction(
+                startNewOrchestration=pb.StartNewOrchestrationAction(
+                    instanceId=instance_id,
+                    name=orchestration_name,
+                    input=helpers.get_string_value(encoded_input),
+                    version=None,
+                    scheduledTime=None,
+                    requestTime=None,
+                    parentTraceContext=None
+                )
+            )
+        )
+        return instance_id
+
+    @property
+    def entity_id(self) -> EntityInstanceId:
+        """Get the ID of the entity instance.
+
+        Returns
+        -------
+        str
+            The ID of the current entity instance.
+        """
+        return self._entity_id

durabletask/entities/entity_instance_id.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+
+class EntityInstanceId:
+    def __init__(self, entity: str, key: str):
+        self.entity = entity
+        self.key = key
+
+    def __str__(self) -> str:
+        return f"@{self.entity}@{self.key}"
+
+    def __eq__(self, other):
+        if not isinstance(other, EntityInstanceId):
+            return False
+        return self.entity == other.entity and self.key == other.key
+
+    def __lt__(self, other):
+        if not isinstance(other, EntityInstanceId):
+            return self < other
+        return str(self) < str(other)
+
+    @staticmethod
+    def parse(entity_id: str) -> Optional["EntityInstanceId"]:
+        """Parse a string representation of an entity ID into an EntityInstanceId object.
+
+        Parameters
+        ----------
+        entity_id : str
+            The string representation of the entity ID, in the format '@entity@key'.
+
+        Returns
+        -------
+        Optional[EntityInstanceId]
+            The parsed EntityInstanceId object, or None if the input is None.
+        """
+        try:
+            _, entity, key = entity_id.split("@", 2)
+            return EntityInstanceId(entity=entity, key=key)
+        except ValueError as ex:
+            raise ValueError("Invalid entity ID format", ex)

durabletask/entities/entity_lock.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from durabletask.task import OrchestrationContext
+
+
+class EntityLock:
+    # Note: This should
+    def __init__(self, context: 'OrchestrationContext'):
+        self._context = context
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._context._exit_critical_section()

durabletask/internal/entity_state_shim.py

@@ -0,0 +1,66 @@
+from typing import Any, TypeVar, Union
+from typing import Optional, Type, overload
+
+import durabletask.internal.orchestrator_service_pb2 as pb
+
+TState = TypeVar("TState")
+
+
+class StateShim:
+    def __init__(self, start_state):
+        self._current_state: Any = start_state
+        self._checkpoint_state: Any = start_state
+        self._operation_actions: list[pb.OperationAction] = []
+        self._actions_checkpoint_state: int = 0
+
+    @overload
+    def get_state(self, intended_type: Type[TState], default: TState) -> TState:
+        ...
+
+    @overload
+    def get_state(self, intended_type: Type[TState]) -> Optional[TState]:
+        ...
+
+    @overload
+    def get_state(self, intended_type: None = None, default: Any = None) -> Any:
+        ...
+
+    def get_state(self, intended_type: Optional[Type[TState]] = None, default: Optional[TState] = None) -> Union[None, TState, Any]:
+        if self._current_state is None and default is not None:
+            return default
+
+        if intended_type is None:
+            return self._current_state
+
+        if isinstance(self._current_state, intended_type):
+            return self._current_state
+
+        try:
+            return intended_type(self._current_state)  # type: ignore[call-arg]
+        except Exception as ex:
+            raise TypeError(
+                f"Could not convert state of type '{type(self._current_state).__name__}' to '{intended_type.__name__}'"
+            ) from ex
+
+    def set_state(self, state):
+        self._current_state = state
+
+    def add_operation_action(self, action: pb.OperationAction):
+        self._operation_actions.append(action)
+
+    def get_operation_actions(self) -> list[pb.OperationAction]:
+        return self._operation_actions[:self._actions_checkpoint_state]
+
+    def commit(self):
+        self._checkpoint_state = self._current_state
+        self._actions_checkpoint_state = len(self._operation_actions)
+
+    def rollback(self):
+        self._current_state = self._checkpoint_state
+        self._operation_actions = self._operation_actions[:self._actions_checkpoint_state]
+
+    def reset(self):
+        self._current_state = None
+        self._checkpoint_state = None
+        self._operation_actions = []
+        self._actions_checkpoint_state = 0

durabletask/internal/exceptions.py

@@ -0,0 +1,11 @@
+import durabletask.internal.orchestrator_service_pb2 as pb
+
+
+class VersionFailureException(Exception):
+    def __init__(self, error_details: pb.TaskFailureDetails) -> None:
+        super().__init__()
+        self.error_details = error_details
+
+
+class AbandonOrchestrationError(Exception):
+    pass

durabletask/internal/grpc_interceptor.py

@@ -0,0 +1,65 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from collections import namedtuple
+
+import grpc
+
+
+class _ClientCallDetails(
+        namedtuple(
+            '_ClientCallDetails',
+            ['method', 'timeout', 'metadata', 'credentials', 'wait_for_ready', 'compression']),
+        grpc.ClientCallDetails):
+    """This is an implementation of the ClientCallDetails interface needed for interceptors.
+    This class takes six named values and inherits the ClientCallDetails from grpc package.
+    This class encloses the values that describe a RPC to be invoked.
+    """
+    pass
+
+
+class DefaultClientInterceptorImpl (
+        grpc.UnaryUnaryClientInterceptor, grpc.UnaryStreamClientInterceptor,
+        grpc.StreamUnaryClientInterceptor, grpc.StreamStreamClientInterceptor):
+    """The class implements a UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor,
+    StreamUnaryClientInterceptor and StreamStreamClientInterceptor from grpc to add an
+    interceptor to add additional headers to all calls as needed."""
+
+    def __init__(self, metadata: list[tuple[str, str]]):
+        super().__init__()
+        self._metadata = metadata
+
+    def _intercept_call(
+            self, client_call_details: _ClientCallDetails) -> grpc.ClientCallDetails:
+        """Internal intercept_call implementation which adds metadata to grpc metadata in the RPC
+            call details."""
+        if self._metadata is None:
+            return client_call_details
+
+        if client_call_details.metadata is not None:
+            metadata = list(client_call_details.metadata)
+        else:
+            metadata = []
+
+        metadata.extend(self._metadata)
+        client_call_details = _ClientCallDetails(
+            client_call_details.method, client_call_details.timeout, metadata,
+            client_call_details.credentials, client_call_details.wait_for_ready, client_call_details.compression)
+
+        return client_call_details
+
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        new_client_call_details = self._intercept_call(client_call_details)
+        return continuation(new_client_call_details, request)
+
+    def intercept_unary_stream(self, continuation, client_call_details, request):
+        new_client_call_details = self._intercept_call(client_call_details)
+        return continuation(new_client_call_details, request)
+
+    def intercept_stream_unary(self, continuation, client_call_details, request):
+        new_client_call_details = self._intercept_call(client_call_details)
+        return continuation(new_client_call_details, request)
+
+    def intercept_stream_stream(self, continuation, client_call_details, request):
+        new_client_call_details = self._intercept_call(client_call_details)
+        return continuation(new_client_call_details, request)