durabletask 1.4.0.dev30__py3-none-any.whl → 1.4.0.dev32__py3-none-any.whl

durabletask/__init__.py

@@ -3,6 +3,7 @@
 
 """Durable Task SDK for Python"""
 
+from durabletask.grpc_options import GrpcChannelOptions, GrpcRetryPolicyOptions
 from durabletask.payload.store import LargePayloadStorageOptions, PayloadStore
 from durabletask.worker import (
     ActivityWorkItemFilter,
@@ -17,6 +18,8 @@ __all__ = [
     "ActivityWorkItemFilter",
     "ConcurrencyOptions",
     "EntityWorkItemFilter",
+    "GrpcChannelOptions",
+    "GrpcRetryPolicyOptions",
     "LargePayloadStorageOptions",
     "OrchestrationWorkItemFilter",
     "PayloadStore",

durabletask/client.py

@@ -6,14 +6,17 @@ import uuid
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Any, List, Optional, Sequence, TypeVar, Union
+from typing import Any, Generic, List, Optional, Sequence, TypeVar, Union
 
 import grpc
 import grpc.aio
 
+import durabletask.history as history
 from durabletask.entities import EntityInstanceId
 from durabletask.entities.entity_metadata import EntityMetadata
+from durabletask.grpc_options import GrpcChannelOptions
 import durabletask.internal.helpers as helpers
+import durabletask.internal.history_helpers as history_helpers
 import durabletask.internal.orchestrator_service_pb2 as pb
 import durabletask.internal.orchestrator_service_pb2_grpc as stubs
 import durabletask.internal.shared as shared
@@ -37,6 +40,7 @@ from durabletask.payload.store import PayloadStore
 
 TInput = TypeVar('TInput')
 TOutput = TypeVar('TOutput')
+TItem = TypeVar('TItem')
 
 
 class OrchestrationStatus(Enum):
@@ -99,6 +103,12 @@ class PurgeInstancesResult:
     is_complete: bool
 
 
+@dataclass
+class Page(Generic[TItem]):
+    items: List[TItem]
+    continuation_token: Optional[str]
+
+
 @dataclass
 class CleanEntityStorageResult:
     empty_entities_removed: int
@@ -152,18 +162,22 @@ class TaskHubGrpcClient:
                  metadata: Optional[list[tuple[str, str]]] = None,
                  log_handler: Optional[logging.Handler] = None,
                  log_formatter: Optional[logging.Formatter] = None,
+                 channel: Optional[grpc.Channel] = None,
                  secure_channel: bool = False,
                  interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
+                 channel_options: Optional[GrpcChannelOptions] = None,
                  default_version: Optional[str] = None,
                  payload_store: Optional[PayloadStore] = None):
 
-        interceptors = prepare_sync_interceptors(metadata, interceptors)
-
-        channel = shared.get_grpc_channel(
-            host_address=host_address,
-            secure_channel=secure_channel,
-            interceptors=interceptors
-        )
+        self._owns_channel = channel is None
+        if channel is None:
+            interceptors = prepare_sync_interceptors(metadata, interceptors)
+            channel = shared.get_grpc_channel(
+                host_address=host_address,
+                secure_channel=secure_channel,
+                interceptors=interceptors,
+                channel_options=channel_options,
+            )
         self._channel = channel
         self._stub = stubs.TaskHubSidecarServiceStub(channel)
         self._logger = shared.get_logger("client", log_handler, log_formatter)
@@ -171,8 +185,15 @@ class TaskHubGrpcClient:
         self._payload_store = payload_store
 
     def close(self) -> None:
-        """Closes the underlying gRPC channel."""
-        self._channel.close()
+        """Closes the underlying gRPC channel.
+
+        Only closes channels created internally. If a pre-configured channel
+        was passed via the ``channel`` constructor parameter, this method is
+        a no-op — the caller retains ownership and is responsible for closing
+        it.
+        """
+        if self._owns_channel:
+            self._channel.close()
 
     def schedule_new_orchestration(self, orchestrator: Union[task.Orchestrator[TInput, TOutput], str], *,
                                    input: Optional[TInput] = None,
@@ -218,6 +239,44 @@ class TaskHubGrpcClient:
             payload_helpers.deexternalize_payloads(res, self._payload_store)
         return new_orchestration_state(req.instanceId, res)
 
+    def get_orchestration_history(self,
+                                  instance_id: str, *,
+                                  execution_id: Optional[str] = None,
+                                  for_work_item_processing: bool = False) -> List[history.HistoryEvent]:
+        req = pb.StreamInstanceHistoryRequest(
+            instanceId=instance_id,
+            executionId=helpers.get_string_value(execution_id),
+            forWorkItemProcessing=for_work_item_processing,
+        )
+        self._logger.info(f"Retrieving history for instance '{instance_id}'.")
+        stream = self._stub.StreamInstanceHistory(req)
+        return history_helpers.collect_history_events(stream, self._payload_store)
+
+    def list_instance_ids(self,
+                          runtime_status: Optional[List[OrchestrationStatus]] = None,
+                          completed_time_from: Optional[datetime] = None,
+                          completed_time_to: Optional[datetime] = None,
+                          page_size: Optional[int] = None,
+                          continuation_token: Optional[str] = None) -> Page[str]:
+        req = pb.ListInstanceIdsRequest(
+            runtimeStatus=[status.value for status in runtime_status] if runtime_status else [],
+            completedTimeFrom=helpers.new_timestamp(completed_time_from) if completed_time_from else None,
+            completedTimeTo=helpers.new_timestamp(completed_time_to) if completed_time_to else None,
+            pageSize=page_size or 0,
+            lastInstanceKey=helpers.get_string_value(continuation_token),
+        )
+        self._logger.info(
+            "Listing terminal instance IDs with filters: "
+            f"runtime_status={[str(status) for status in runtime_status] if runtime_status else None}, "
+            f"completed_time_from={completed_time_from}, "
+            f"completed_time_to={completed_time_to}, "
+            f"page_size={page_size}, "
+            f"continuation_token={continuation_token}"
+        )
+        resp: pb.ListInstanceIdsResponse = self._stub.ListInstanceIds(req)
+        next_token = resp.lastInstanceKey.value if resp.HasField("lastInstanceKey") else None
+        return Page(items=list(resp.instanceIds), continuation_token=next_token)
+
     def get_all_orchestration_states(self,
                                      orchestration_query: Optional[OrchestrationQuery] = None
                                      ) -> List[OrchestrationState]:
@@ -433,18 +492,22 @@ class AsyncTaskHubGrpcClient:
                  metadata: Optional[list[tuple[str, str]]] = None,
                  log_handler: Optional[logging.Handler] = None,
                  log_formatter: Optional[logging.Formatter] = None,
+                 channel: Optional[grpc.aio.Channel] = None,
                  secure_channel: bool = False,
                  interceptors: Optional[Sequence[shared.AsyncClientInterceptor]] = None,
+                 channel_options: Optional[GrpcChannelOptions] = None,
                  default_version: Optional[str] = None,
                  payload_store: Optional[PayloadStore] = None):
 
-        interceptors = prepare_async_interceptors(metadata, interceptors)
-
-        channel = shared.get_async_grpc_channel(
-            host_address=host_address,
-            secure_channel=secure_channel,
-            interceptors=interceptors
-        )
+        self._owns_channel = channel is None
+        if channel is None:
+            interceptors = prepare_async_interceptors(metadata, interceptors)
+            channel = shared.get_async_grpc_channel(
+                host_address=host_address,
+                secure_channel=secure_channel,
+                interceptors=interceptors,
+                channel_options=channel_options,
+            )
         self._channel = channel
         self._stub = stubs.TaskHubSidecarServiceStub(channel)
         self._logger = shared.get_logger("async_client", log_handler, log_formatter)
@@ -452,8 +515,15 @@ class AsyncTaskHubGrpcClient:
         self._payload_store = payload_store
 
     async def close(self) -> None:
-        """Closes the underlying gRPC channel."""
-        await self._channel.close()
+        """Closes the underlying gRPC channel.
+
+        Only closes channels created internally. If a pre-configured channel
+        was passed via the ``channel`` constructor parameter, this method is
+        a no-op — the caller retains ownership and is responsible for closing
+        it.
+        """
+        if self._owns_channel:
+            await self._channel.close()
 
     async def __aenter__(self):
         return self
@@ -502,6 +572,44 @@ class AsyncTaskHubGrpcClient:
             await payload_helpers.deexternalize_payloads_async(res, self._payload_store)
         return new_orchestration_state(req.instanceId, res)
 
+    async def get_orchestration_history(self,
+                                        instance_id: str, *,
+                                        execution_id: Optional[str] = None,
+                                        for_work_item_processing: bool = False) -> List[history.HistoryEvent]:
+        req = pb.StreamInstanceHistoryRequest(
+            instanceId=instance_id,
+            executionId=helpers.get_string_value(execution_id),
+            forWorkItemProcessing=for_work_item_processing,
+        )
+        self._logger.info(f"Retrieving history for instance '{instance_id}'.")
+        stream = self._stub.StreamInstanceHistory(req)
+        return await history_helpers.collect_history_events_async(stream, self._payload_store)
+
+    async def list_instance_ids(self,
+                                runtime_status: Optional[List[OrchestrationStatus]] = None,
+                                completed_time_from: Optional[datetime] = None,
+                                completed_time_to: Optional[datetime] = None,
+                                page_size: Optional[int] = None,
+                                continuation_token: Optional[str] = None) -> Page[str]:
+        req = pb.ListInstanceIdsRequest(
+            runtimeStatus=[status.value for status in runtime_status] if runtime_status else [],
+            completedTimeFrom=helpers.new_timestamp(completed_time_from) if completed_time_from else None,
+            completedTimeTo=helpers.new_timestamp(completed_time_to) if completed_time_to else None,
+            pageSize=page_size or 0,
+            lastInstanceKey=helpers.get_string_value(continuation_token),
+        )
+        self._logger.info(
+            "Listing terminal instance IDs with filters: "
+            f"runtime_status={[str(status) for status in runtime_status] if runtime_status else None}, "
+            f"completed_time_from={completed_time_from}, "
+            f"completed_time_to={completed_time_to}, "
+            f"page_size={page_size}, "
+            f"continuation_token={continuation_token}"
+        )
+        resp: pb.ListInstanceIdsResponse = await self._stub.ListInstanceIds(req)
+        next_token = resp.lastInstanceKey.value if resp.HasField("lastInstanceKey") else None
+        return Page(items=list(resp.instanceIds), continuation_token=next_token)
+
     async def get_all_orchestration_states(self,
                                            orchestration_query: Optional[OrchestrationQuery] = None
                                            ) -> List[OrchestrationState]:

durabletask/grpc_options.py

@@ -0,0 +1,102 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import json
+from typing import Any, Optional
+
+
+@dataclass
+class GrpcRetryPolicyOptions:
+    """Configuration for transport-level gRPC retries."""
+
+    max_attempts: int = 4
+    initial_backoff_seconds: float = 0.05
+    max_backoff_seconds: float = 0.25
+    backoff_multiplier: float = 2.0
+    retryable_status_codes: list[str] = field(default_factory=lambda: ["UNAVAILABLE"])
+
+    def __post_init__(self) -> None:
+        if self.max_attempts < 2:
+            raise ValueError("max_attempts must be >= 2")
+        if self.initial_backoff_seconds <= 0:
+            raise ValueError("initial_backoff_seconds must be > 0")
+        if self.max_backoff_seconds <= 0:
+            raise ValueError("max_backoff_seconds must be > 0")
+        if self.backoff_multiplier <= 0:
+            raise ValueError("backoff_multiplier must be > 0")
+        if self.max_backoff_seconds < self.initial_backoff_seconds:
+            raise ValueError("max_backoff_seconds must be >= initial_backoff_seconds")
+        if len(self.retryable_status_codes) == 0:
+            raise ValueError("retryable_status_codes cannot be empty")
+        # Validate that backoff values are representable as non-zero gRPC duration strings.
+        self._format_duration(self.initial_backoff_seconds)
+        self._format_duration(self.max_backoff_seconds)
+
+    @staticmethod
+    def _format_duration(seconds: float) -> str:
+        formatted = f"{seconds:.9f}".rstrip('0')
+        if formatted.endswith('.'):
+            formatted += '0'
+        if float(formatted) == 0:
+            raise ValueError(
+                f"Duration {seconds!r} rounds to zero; use a value large enough to "
+                "produce a non-zero gRPC duration string."
+            )
+        return f"{formatted}s"
+
+    def to_service_config(self) -> dict[str, Any]:
+        return {
+            "methodConfig": [
+                {
+                    "name": [{}],
+                    "retryPolicy": {
+                        "maxAttempts": self.max_attempts,
+                        "initialBackoff": self._format_duration(self.initial_backoff_seconds),
+                        "maxBackoff": self._format_duration(self.max_backoff_seconds),
+                        "backoffMultiplier": self.backoff_multiplier,
+                        "retryableStatusCodes": self.retryable_status_codes,
+                    },
+                }
+            ]
+        }
+
+
+@dataclass
+class GrpcChannelOptions:
+    """Configuration for transport-level gRPC channel behavior."""
+
+    max_receive_message_length: Optional[int] = None
+    max_send_message_length: Optional[int] = None
+    keepalive_time_ms: Optional[int] = None
+    keepalive_timeout_ms: Optional[int] = None
+    keepalive_permit_without_calls: Optional[bool] = None
+    retry_policy: Optional[GrpcRetryPolicyOptions] = None
+    raw_options: list[tuple[str, Any]] = field(default_factory=list)
+
+    def to_grpc_options(self) -> list[tuple[str, Any]]:
+        options = list(self.raw_options)
+
+        if self.max_receive_message_length is not None:
+            options.append(("grpc.max_receive_message_length", self.max_receive_message_length))
+        if self.max_send_message_length is not None:
+            options.append(("grpc.max_send_message_length", self.max_send_message_length))
+        if self.keepalive_time_ms is not None:
+            options.append(("grpc.keepalive_time_ms", self.keepalive_time_ms))
+        if self.keepalive_timeout_ms is not None:
+            options.append(("grpc.keepalive_timeout_ms", self.keepalive_timeout_ms))
+        if self.keepalive_permit_without_calls is not None:
+            options.append(
+                (
+                    "grpc.keepalive_permit_without_calls",
+                    1 if self.keepalive_permit_without_calls else 0,
+                )
+            )
+
+        if self.retry_policy is not None:
+            options.append(("grpc.enable_retries", 1))
+            options.append(("grpc.service_config", json.dumps(self.retry_policy.to_service_config())))
+
+        return options

durabletask/history.py

@@ -0,0 +1,535 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from google.protobuf import json_format
+from google.protobuf.message import Message
+
+from durabletask import task
+import durabletask.internal.orchestrator_service_pb2 as pb
+
+
+@dataclass(slots=True)
+class OrchestrationInstance:
+    instance_id: str
+    execution_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ParentInstanceInfo:
+    task_scheduled_id: int
+    name: Optional[str] = None
+    version: Optional[str] = None
+    orchestration_instance: Optional[OrchestrationInstance] = None
+
+
+@dataclass(slots=True)
+class TraceContext:
+    trace_parent: str
+    span_id: str
+    trace_state: Optional[str] = None
+
+
+@dataclass(slots=True)
+class HistoryEvent:
+    event_id: int
+    timestamp: datetime
+
+    def to_dict(self) -> dict[str, Any]:
+        return _to_serializable(asdict(self))
+
+
+@dataclass(slots=True)
+class ExecutionStartedEvent(HistoryEvent):
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    orchestration_instance: Optional[OrchestrationInstance] = None
+    parent_instance: Optional[ParentInstanceInfo] = None
+    scheduled_start_timestamp: Optional[datetime] = None
+    parent_trace_context: Optional[TraceContext] = None
+    orchestration_span_id: Optional[str] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class ExecutionCompletedEvent(HistoryEvent):
+    orchestration_status: int
+    result: Optional[str] = None
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class ExecutionTerminatedEvent(HistoryEvent):
+    input: Optional[str] = None
+    recurse: bool = False
+
+
+@dataclass(slots=True)
+class TaskScheduledEvent(HistoryEvent):
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class TaskCompletedEvent(HistoryEvent):
+    task_scheduled_id: int
+    result: Optional[str] = None
+
+
+@dataclass(slots=True)
+class TaskFailedEvent(HistoryEvent):
+    task_scheduled_id: int
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceCreatedEvent(HistoryEvent):
+    instance_id: str
+    name: str
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    tags: Optional[dict[str, str]] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceCompletedEvent(HistoryEvent):
+    task_scheduled_id: int
+    result: Optional[str] = None
+
+
+@dataclass(slots=True)
+class SubOrchestrationInstanceFailedEvent(HistoryEvent):
+    task_scheduled_id: int
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class TimerCreatedEvent(HistoryEvent):
+    fire_at: datetime
+
+
+@dataclass(slots=True)
+class TimerFiredEvent(HistoryEvent):
+    fire_at: datetime
+    timer_id: int
+
+
+@dataclass(slots=True)
+class OrchestratorStartedEvent(HistoryEvent):
+    pass
+
+
+@dataclass(slots=True)
+class OrchestratorCompletedEvent(HistoryEvent):
+    pass
+
+
+@dataclass(slots=True)
+class EventSentEvent(HistoryEvent):
+    instance_id: str
+    name: str
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EventRaisedEvent(HistoryEvent):
+    name: str
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class GenericEvent(HistoryEvent):
+    data: Optional[str] = None
+
+
+@dataclass(slots=True)
+class HistoryStateEvent(HistoryEvent):
+    orchestration_state: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ContinueAsNewEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionSuspendedEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionResumedEvent(HistoryEvent):
+    input: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationSignaledEvent(HistoryEvent):
+    request_id: str
+    operation: str
+    scheduled_time: Optional[datetime] = None
+    input: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationCalledEvent(HistoryEvent):
+    request_id: str
+    operation: str
+    scheduled_time: Optional[datetime] = None
+    input: Optional[str] = None
+    parent_instance_id: Optional[str] = None
+    parent_execution_id: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationCompletedEvent(HistoryEvent):
+    request_id: str
+    output: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityOperationFailedEvent(HistoryEvent):
+    request_id: str
+    failure_details: Optional[task.FailureDetails] = None
+
+
+@dataclass(slots=True)
+class EntityLockRequestedEvent(HistoryEvent):
+    critical_section_id: str
+    lock_set: list[str]
+    position: int
+    parent_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class EntityLockGrantedEvent(HistoryEvent):
+    critical_section_id: str
+
+
+@dataclass(slots=True)
+class EntityUnlockSentEvent(HistoryEvent):
+    critical_section_id: str
+    parent_instance_id: Optional[str] = None
+    target_instance_id: Optional[str] = None
+
+
+@dataclass(slots=True)
+class ExecutionRewoundEvent(HistoryEvent):
+    reason: Optional[str] = None
+    parent_execution_id: Optional[str] = None
+    instance_id: Optional[str] = None
+    parent_trace_context: Optional[TraceContext] = None
+    name: Optional[str] = None
+    version: Optional[str] = None
+    input: Optional[str] = None
+    parent_instance: Optional[ParentInstanceInfo] = None
+    tags: Optional[dict[str, str]] = None
+
+
+def _from_protobuf(event: pb.HistoryEvent) -> HistoryEvent:
+    event_type = event.WhichOneof('eventType')
+    if event_type is None:
+        raise ValueError('History event does not have an eventType set')
+    converter = _EVENT_CONVERTERS.get(event_type)
+    if converter is None:
+        raise ValueError(f'Unsupported history event type: {event_type}')
+    return converter(event)
+
+
+def to_dict(event: HistoryEvent) -> dict[str, Any]:
+    return event.to_dict()
+
+
+def _base_kwargs(event: pb.HistoryEvent) -> dict[str, Any]:
+    return {
+        'event_id': event.eventId,
+        'timestamp': event.timestamp.ToDatetime(timezone.utc),
+    }
+
+
+def _string_value(msg: Message, field_name: str) -> Optional[str]:
+    if msg.HasField(field_name):
+        return getattr(msg, field_name).value
+    return None
+
+
+def _timestamp_value(msg: Message, field_name: str) -> Optional[datetime]:
+    if msg.HasField(field_name):
+        return getattr(msg, field_name).ToDatetime(timezone.utc)
+    return None
+
+
+def _failure_details(msg: Message, field_name: str) -> Optional[task.FailureDetails]:
+    if not msg.HasField(field_name):
+        return None
+    details = getattr(msg, field_name)
+    return task.FailureDetails(
+        details.errorMessage,
+        details.errorType,
+        details.stackTrace.value if details.HasField('stackTrace') else None,
+    )
+
+
+def _trace_context(msg: Message, field_name: str) -> Optional[TraceContext]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    return TraceContext(
+        trace_parent=value.traceParent,
+        span_id=value.spanID,
+        trace_state=value.traceState.value if value.HasField('traceState') else None,
+    )
+
+
+def _orchestration_instance(msg: Message, field_name: str) -> Optional[OrchestrationInstance]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    return OrchestrationInstance(
+        instance_id=value.instanceId,
+        execution_id=value.executionId.value if value.HasField('executionId') else None,
+    )
+
+
+def _parent_instance(msg: Message, field_name: str) -> Optional[ParentInstanceInfo]:
+    if not msg.HasField(field_name):
+        return None
+    value = getattr(msg, field_name)
+    orchestration_instance = None
+    if value.HasField('orchestrationInstance'):
+        orchestration_instance = OrchestrationInstance(
+            instance_id=value.orchestrationInstance.instanceId,
+            execution_id=value.orchestrationInstance.executionId.value
+            if value.orchestrationInstance.HasField('executionId') else None,
+        )
+    return ParentInstanceInfo(
+        task_scheduled_id=value.taskScheduledId,
+        name=value.name.value if value.HasField('name') else None,
+        version=value.version.value if value.HasField('version') else None,
+        orchestration_instance=orchestration_instance,
+    )
+
+
+def _message_to_dict(msg: Message) -> dict[str, Any]:
+    return json_format.MessageToDict(msg, preserving_proto_field_name=True)
+
+
+def _to_serializable(value: Any) -> Any:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, list):
+        return [_to_serializable(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _to_serializable(item) for key, item in value.items()}
+    return value
+
+
+_EVENT_CONVERTERS: dict[str, Any] = {
+    'executionStarted': lambda event: ExecutionStartedEvent(
+        **_base_kwargs(event),
+        name=event.executionStarted.name,
+        version=_string_value(event.executionStarted, 'version'),
+        input=_string_value(event.executionStarted, 'input'),
+        orchestration_instance=_orchestration_instance(event.executionStarted, 'orchestrationInstance'),
+        parent_instance=_parent_instance(event.executionStarted, 'parentInstance'),
+        scheduled_start_timestamp=_timestamp_value(event.executionStarted, 'scheduledStartTimestamp'),
+        parent_trace_context=_trace_context(event.executionStarted, 'parentTraceContext'),
+        orchestration_span_id=_string_value(event.executionStarted, 'orchestrationSpanID'),
+        tags=dict(event.executionStarted.tags) if event.executionStarted.tags else None,
+    ),
+    'executionCompleted': lambda event: ExecutionCompletedEvent(
+        **_base_kwargs(event),
+        orchestration_status=event.executionCompleted.orchestrationStatus,
+        result=_string_value(event.executionCompleted, 'result'),
+        failure_details=_failure_details(event.executionCompleted, 'failureDetails'),
+    ),
+    'executionTerminated': lambda event: ExecutionTerminatedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionTerminated, 'input'),
+        recurse=event.executionTerminated.recurse,
+    ),
+    'taskScheduled': lambda event: TaskScheduledEvent(
+        **_base_kwargs(event),
+        name=event.taskScheduled.name,
+        version=_string_value(event.taskScheduled, 'version'),
+        input=_string_value(event.taskScheduled, 'input'),
+        parent_trace_context=_trace_context(event.taskScheduled, 'parentTraceContext'),
+        tags=dict(event.taskScheduled.tags) if event.taskScheduled.tags else None,
+    ),
+    'taskCompleted': lambda event: TaskCompletedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.taskCompleted.taskScheduledId,
+        result=_string_value(event.taskCompleted, 'result'),
+    ),
+    'taskFailed': lambda event: TaskFailedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.taskFailed.taskScheduledId,
+        failure_details=_failure_details(event.taskFailed, 'failureDetails'),
+    ),
+    'subOrchestrationInstanceCreated': lambda event: SubOrchestrationInstanceCreatedEvent(
+        **_base_kwargs(event),
+        instance_id=event.subOrchestrationInstanceCreated.instanceId,
+        name=event.subOrchestrationInstanceCreated.name,
+        version=_string_value(event.subOrchestrationInstanceCreated, 'version'),
+        input=_string_value(event.subOrchestrationInstanceCreated, 'input'),
+        parent_trace_context=_trace_context(event.subOrchestrationInstanceCreated, 'parentTraceContext'),
+        tags=dict(event.subOrchestrationInstanceCreated.tags) if event.subOrchestrationInstanceCreated.tags else None,
+    ),
+    'subOrchestrationInstanceCompleted': lambda event: SubOrchestrationInstanceCompletedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.subOrchestrationInstanceCompleted.taskScheduledId,
+        result=_string_value(event.subOrchestrationInstanceCompleted, 'result'),
+    ),
+    'subOrchestrationInstanceFailed': lambda event: SubOrchestrationInstanceFailedEvent(
+        **_base_kwargs(event),
+        task_scheduled_id=event.subOrchestrationInstanceFailed.taskScheduledId,
+        failure_details=_failure_details(event.subOrchestrationInstanceFailed, 'failureDetails'),
+    ),
+    'timerCreated': lambda event: TimerCreatedEvent(
+        **_base_kwargs(event),
+        fire_at=event.timerCreated.fireAt.ToDatetime(timezone.utc),
+    ),
+    'timerFired': lambda event: TimerFiredEvent(
+        **_base_kwargs(event),
+        fire_at=event.timerFired.fireAt.ToDatetime(timezone.utc),
+        timer_id=event.timerFired.timerId,
+    ),
+    'orchestratorStarted': lambda event: OrchestratorStartedEvent(**_base_kwargs(event)),
+    'orchestratorCompleted': lambda event: OrchestratorCompletedEvent(**_base_kwargs(event)),
+    'eventSent': lambda event: EventSentEvent(
+        **_base_kwargs(event),
+        instance_id=event.eventSent.instanceId,
+        name=event.eventSent.name,
+        input=_string_value(event.eventSent, 'input'),
+    ),
+    'eventRaised': lambda event: EventRaisedEvent(
+        **_base_kwargs(event),
+        name=event.eventRaised.name,
+        input=_string_value(event.eventRaised, 'input'),
+    ),
+    'genericEvent': lambda event: GenericEvent(
+        **_base_kwargs(event),
+        data=_string_value(event.genericEvent, 'data'),
+    ),
+    'historyState': lambda event: HistoryStateEvent(
+        **_base_kwargs(event),
+        orchestration_state=_message_to_dict(event.historyState.orchestrationState),
+    ),
+    'continueAsNew': lambda event: ContinueAsNewEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.continueAsNew, 'input'),
+    ),
+    'executionSuspended': lambda event: ExecutionSuspendedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionSuspended, 'input'),
+    ),
+    'executionResumed': lambda event: ExecutionResumedEvent(
+        **_base_kwargs(event),
+        input=_string_value(event.executionResumed, 'input'),
+    ),
+    'entityOperationSignaled': lambda event: EntityOperationSignaledEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationSignaled.requestId,
+        operation=event.entityOperationSignaled.operation,
+        scheduled_time=_timestamp_value(event.entityOperationSignaled, 'scheduledTime'),
+        input=_string_value(event.entityOperationSignaled, 'input'),
+        target_instance_id=_string_value(event.entityOperationSignaled, 'targetInstanceId'),
+    ),
+    'entityOperationCalled': lambda event: EntityOperationCalledEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationCalled.requestId,
+        operation=event.entityOperationCalled.operation,
+        scheduled_time=_timestamp_value(event.entityOperationCalled, 'scheduledTime'),
+        input=_string_value(event.entityOperationCalled, 'input'),
+        parent_instance_id=_string_value(event.entityOperationCalled, 'parentInstanceId'),
+        parent_execution_id=_string_value(event.entityOperationCalled, 'parentExecutionId'),
+        target_instance_id=_string_value(event.entityOperationCalled, 'targetInstanceId'),
+    ),
+    'entityOperationCompleted': lambda event: EntityOperationCompletedEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationCompleted.requestId,
+        output=_string_value(event.entityOperationCompleted, 'output'),
+    ),
+    'entityOperationFailed': lambda event: EntityOperationFailedEvent(
+        **_base_kwargs(event),
+        request_id=event.entityOperationFailed.requestId,
+        failure_details=_failure_details(event.entityOperationFailed, 'failureDetails'),
+    ),
+    'entityLockRequested': lambda event: EntityLockRequestedEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityLockRequested.criticalSectionId,
+        lock_set=list(event.entityLockRequested.lockSet),
+        position=event.entityLockRequested.position,
+        parent_instance_id=_string_value(event.entityLockRequested, 'parentInstanceId'),
+    ),
+    'entityLockGranted': lambda event: EntityLockGrantedEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityLockGranted.criticalSectionId,
+    ),
+    'entityUnlockSent': lambda event: EntityUnlockSentEvent(
+        **_base_kwargs(event),
+        critical_section_id=event.entityUnlockSent.criticalSectionId,
+        parent_instance_id=_string_value(event.entityUnlockSent, 'parentInstanceId'),
+        target_instance_id=_string_value(event.entityUnlockSent, 'targetInstanceId'),
+    ),
+    'executionRewound': lambda event: ExecutionRewoundEvent(
+        **_base_kwargs(event),
+        reason=_string_value(event.executionRewound, 'reason'),
+        parent_execution_id=_string_value(event.executionRewound, 'parentExecutionId'),
+        instance_id=_string_value(event.executionRewound, 'instanceId'),
+        parent_trace_context=_trace_context(event.executionRewound, 'parentTraceContext'),
+        name=_string_value(event.executionRewound, 'name'),
+        version=_string_value(event.executionRewound, 'version'),
+        input=_string_value(event.executionRewound, 'input'),
+        parent_instance=_parent_instance(event.executionRewound, 'parentInstance'),
+        tags=dict(event.executionRewound.tags) if event.executionRewound.tags else None,
+    ),
+}
+
+
+__all__ = [
+    'ContinueAsNewEvent',
+    'EntityLockGrantedEvent',
+    'EntityLockRequestedEvent',
+    'EntityOperationCalledEvent',
+    'EntityOperationCompletedEvent',
+    'EntityOperationFailedEvent',
+    'EntityOperationSignaledEvent',
+    'EntityUnlockSentEvent',
+    'EventRaisedEvent',
+    'EventSentEvent',
+    'ExecutionCompletedEvent',
+    'ExecutionResumedEvent',
+    'ExecutionRewoundEvent',
+    'ExecutionStartedEvent',
+    'ExecutionSuspendedEvent',
+    'ExecutionTerminatedEvent',
+    'GenericEvent',
+    'HistoryEvent',
+    'HistoryStateEvent',
+    'OrchestrationInstance',
+    'OrchestratorCompletedEvent',
+    'OrchestratorStartedEvent',
+    'ParentInstanceInfo',
+    'SubOrchestrationInstanceCompletedEvent',
+    'SubOrchestrationInstanceCreatedEvent',
+    'SubOrchestrationInstanceFailedEvent',
+    'TaskCompletedEvent',
+    'TaskFailedEvent',
+    'TaskScheduledEvent',
+    'TimerCreatedEvent',
+    'TimerFiredEvent',
+    'TraceContext',
+    'to_dict',
+]

durabletask/internal/history_helpers.py

@@ -0,0 +1,68 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from typing import AsyncIterable, Iterable, Optional
+
+import durabletask.history as history
+import durabletask.internal.orchestrator_service_pb2 as pb
+from durabletask.payload import helpers as payload_helpers
+from durabletask.payload.store import PayloadStore
+
+
+def collect_history_events(
+    chunks: Iterable[pb.HistoryChunk],
+    payload_store: Optional[PayloadStore] = None,
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for chunk in chunks:
+        events.extend(_clone_and_convert_events(chunk.events, payload_store))
+    return events
+
+
+async def collect_history_events_async(
+    chunks: AsyncIterable[pb.HistoryChunk],
+    payload_store: Optional[PayloadStore] = None,
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    async for chunk in chunks:
+        events.extend(await _clone_and_convert_events_async(chunk.events, payload_store))
+    return events
+
+
+def history_event_to_dict(event: history.HistoryEvent) -> dict:
+    return history.to_dict(event)
+
+
+def _clone_and_convert_events(
+    source_events: Iterable[pb.HistoryEvent],
+    payload_store: Optional[PayloadStore],
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for source_event in source_events:
+        event = source_event
+        if payload_store is not None:
+            # deexternalize_payloads mutates messages in-place, so clone to avoid
+            # mutating protobuf instances owned by gRPC/deserializer internals.
+            event = pb.HistoryEvent()
+            event.CopyFrom(source_event)
+            payload_helpers.deexternalize_payloads(event, payload_store)
+        events.append(history._from_protobuf(event))
+    return events
+
+
+async def _clone_and_convert_events_async(
+    source_events: Iterable[pb.HistoryEvent],
+    payload_store: Optional[PayloadStore],
+) -> list[history.HistoryEvent]:
+    events: list[history.HistoryEvent] = []
+    for source_event in source_events:
+        event = source_event
+        if payload_store is not None:
+            # Async deexternalization mutates messages in-place, so clone first.
+            event = pb.HistoryEvent()
+            event.CopyFrom(source_event)
+            await payload_helpers.deexternalize_payloads_async(event, payload_store)
+        events.append(history._from_protobuf(event))
+    return events

durabletask/internal/shared.py

@@ -9,6 +9,7 @@ from typing import Any, Optional, Sequence, Union
 
 import grpc
 import grpc.aio
+from durabletask.grpc_options import GrpcChannelOptions
 
 ClientInterceptor = Union[
     grpc.UnaryUnaryClientInterceptor,
@@ -39,7 +40,8 @@ def get_default_host_address() -> str:
 def get_grpc_channel(
         host_address: Optional[str],
         secure_channel: bool = False,
-        interceptors: Optional[Sequence[ClientInterceptor]] = None) -> grpc.Channel:
+        interceptors: Optional[Sequence[ClientInterceptor]] = None,
+        channel_options: Optional[GrpcChannelOptions] = None) -> grpc.Channel:
 
     if host_address is None:
         host_address = get_default_host_address()
@@ -59,10 +61,21 @@ def get_grpc_channel(
             break
 
     # Create the base channel
+    options = channel_options.to_grpc_options() if channel_options is not None else None
     if secure_channel:
-        channel = grpc.secure_channel(host_address, grpc.ssl_channel_credentials())
+        if options is None:
+            channel = grpc.secure_channel(host_address, grpc.ssl_channel_credentials())
+        else:
+            channel = grpc.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                options=options,
+            )
     else:
-        channel = grpc.insecure_channel(host_address)
+        if options is None:
+            channel = grpc.insecure_channel(host_address)
+        else:
+            channel = grpc.insecure_channel(host_address, options=options)
 
     # Apply interceptors ONLY if they exist
     if interceptors:
@@ -73,7 +86,8 @@ def get_grpc_channel(
 def get_async_grpc_channel(
         host_address: Optional[str],
         secure_channel: bool = False,
-        interceptors: Optional[Sequence[AsyncClientInterceptor]] = None) -> grpc.aio.Channel:
+        interceptors: Optional[Sequence[AsyncClientInterceptor]] = None,
+        channel_options: Optional[GrpcChannelOptions] = None) -> grpc.aio.Channel:
 
     if host_address is None:
         host_address = get_default_host_address()
@@ -90,14 +104,34 @@ def get_async_grpc_channel(
             host_address = host_address[len(protocol):]
             break
 
+    options = channel_options.to_grpc_options() if channel_options is not None else None
+
     if secure_channel:
-        channel = grpc.aio.secure_channel(
-            host_address, grpc.ssl_channel_credentials(),
-            interceptors=interceptors)
+        if options is None:
+            channel = grpc.aio.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                interceptors=interceptors,
+            )
+        else:
+            channel = grpc.aio.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                interceptors=interceptors,
+                options=options,
+            )
     else:
-        channel = grpc.aio.insecure_channel(
-            host_address,
-            interceptors=interceptors)
+        if options is None:
+            channel = grpc.aio.insecure_channel(
+                host_address,
+                interceptors=interceptors,
+            )
+        else:
+            channel = grpc.aio.insecure_channel(
+                host_address,
+                interceptors=interceptors,
+                options=options,
+            )
 
     return channel
 

durabletask/testing/in_memory_backend.py

@@ -10,6 +10,7 @@ unit testing and integration testing scenarios where a sidecar process
 or external storage is not desired.
 """
 
+import bisect
 import logging
 import threading
 import time
@@ -41,6 +42,7 @@ class OrchestrationInstance:
     custom_status: Optional[str] = None
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     last_updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    completed_at: Optional[datetime] = None
     failure_details: Optional[pb.TaskFailureDetails] = None
     history: list[pb.HistoryEvent] = field(default_factory=list)
     pending_events: list[pb.HistoryEvent] = field(default_factory=list)
@@ -97,6 +99,10 @@ class StateWaiter:
     result: Optional[OrchestrationInstance] = None
 
 
+_DEFAULT_PAGE_SIZE = 100
+_TOKEN_SEP = '|'
+
+
 class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
     """
     In-memory backend for durable orchestrations suitable for testing.
@@ -238,6 +244,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
                 input=request.input.value if request.input else None,
                 created_at=now,
                 last_updated_at=now,
+                completed_at=None,
                 completion_token=self._next_completion_token,
                 tags=dict(request.tags) if request.tags else None,
             )
@@ -453,6 +460,48 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             f"Restarted instance '{request.instanceId}' as '{new_instance_id}'")
         return pb.RestartInstanceResponse(instanceId=new_instance_id)
 
+    def ListInstanceIds(self, request: pb.ListInstanceIdsRequest, context):
+        """Lists terminal orchestration instance IDs with completion-time pagination."""
+        with self._lock:
+            matching = []
+            for instance in self._instances.values():
+                if not self._is_terminal_status(instance.status):
+                    continue
+                if request.runtimeStatus and instance.status not in request.runtimeStatus:
+                    continue
+                if instance.completed_at is None:
+                    continue
+                if request.HasField("completedTimeFrom") and instance.completed_at < request.completedTimeFrom.ToDatetime(timezone.utc):
+                    continue
+                if request.HasField("completedTimeTo") and instance.completed_at >= request.completedTimeTo.ToDatetime(timezone.utc):
+                    continue
+                matching.append(instance)
+
+            matching.sort(key=lambda i: (i.completed_at, i.instance_id))
+            sort_keys = [(i.completed_at, i.instance_id) for i in matching]
+
+            start_index = 0
+            if request.HasField("lastInstanceKey") and request.lastInstanceKey.value:
+                token = request.lastInstanceKey.value
+                sep_idx = token.index(_TOKEN_SEP)
+                token_ts = datetime.fromisoformat(token[:sep_idx]).replace(tzinfo=timezone.utc)
+                token_id = token[sep_idx + 1:]
+                # bisect_right positions us just after the cursor entry
+                start_index = bisect.bisect_right(sort_keys, (token_ts, token_id))
+
+            page_size = request.pageSize if request.pageSize > 0 else _DEFAULT_PAGE_SIZE
+            page = matching[start_index:start_index + page_size]
+            next_token = None
+            if start_index + page_size < len(matching) and page:
+                last = page[-1]
+                encoded = f"{last.completed_at.isoformat()}{_TOKEN_SEP}{last.instance_id}"
+                next_token = wrappers_pb2.StringValue(value=encoded)
+
+        return pb.ListInstanceIdsResponse(
+            instanceIds=[instance.instance_id for instance in page],
+            lastInstanceKey=next_token,
+        )
+
     @staticmethod
     def _parse_work_item_filters(request: pb.GetWorkItemsRequest):
         """Extract filters from the request.
@@ -1084,8 +1133,18 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
         )
 
     def StreamInstanceHistory(self, request: pb.StreamInstanceHistoryRequest, context):
-        """Streams instance history (not implemented)."""
-        context.abort(grpc.StatusCode.UNIMPLEMENTED, "StreamInstanceHistory not implemented")
+        """Streams orchestration history for an instance."""
+        with self._lock:
+            instance = self._instances.get(request.instanceId)
+            if instance is None:
+                context.abort(grpc.StatusCode.NOT_FOUND,
+                              f"Orchestration instance '{request.instanceId}' not found")
+                return
+            history = [self._clone_history_event(event) for event in instance.history]
+
+        chunk_size = 100
+        for offset in range(0, len(history), chunk_size):
+            yield pb.HistoryChunk(events=history[offset:offset + chunk_size])
 
     def CreateTaskHub(self, request: pb.CreateTaskHubRequest, context):
         """Creates task hub resources (no-op for in-memory)."""
@@ -1178,6 +1237,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             input=encoded_input,
             created_at=now,
             last_updated_at=now,
+            completed_at=None,
             completion_token=self._next_completion_token,
         )
         self._next_completion_token += 1
@@ -1239,6 +1299,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             orchestrationStatus=instance.status,
             createdTimestamp=created_ts,
             lastUpdatedTimestamp=updated_ts,
+            completedTimestamp=helpers.new_timestamp(instance.completed_at) if instance.completed_at else None,
             input=wrappers_pb2.StringValue(value=instance.input) if include_payloads and instance.input else None,
             output=wrappers_pb2.StringValue(value=instance.output) if include_payloads and instance.output else None,
             customStatus=wrappers_pb2.StringValue(value=instance.custom_status) if instance.custom_status else None,
@@ -1319,6 +1380,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
         instance.status = status
         instance.output = complete_action.result.value if complete_action.result else None
         instance.failure_details = complete_action.failureDetails if complete_action.failureDetails else None
+        instance.completed_at = datetime.now(timezone.utc) if self._is_terminal_status(status) else None
 
         if status == pb.ORCHESTRATION_STATUS_CONTINUED_AS_NEW:
             # Handle continue-as-new
@@ -1336,6 +1398,7 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
             instance.output = None
             instance.failure_details = None
             instance.status = pb.ORCHESTRATION_STATUS_PENDING
+            instance.completed_at = None
 
             # Save any events that arrived during the in-flight dispatch so
             # they can be appended AFTER the new execution started events.
@@ -1357,6 +1420,12 @@ class InMemoryOrchestrationBackend(stubs.TaskHubSidecarServiceServicer):
 
             self._enqueue_orchestration(instance.instance_id)
 
+    @staticmethod
+    def _clone_history_event(event: pb.HistoryEvent) -> pb.HistoryEvent:
+        cloned_event = pb.HistoryEvent()
+        cloned_event.CopyFrom(event)
+        return cloned_event
+
     def _process_schedule_task_action(self, instance: OrchestrationInstance,
                                       action: pb.OrchestratorAction):
         """Processes a schedule task action."""

durabletask/worker.py

@@ -21,6 +21,7 @@ from packaging.version import InvalidVersion, parse
 import grpc
 from google.protobuf import empty_pb2
 
+from durabletask.grpc_options import GrpcChannelOptions
 from durabletask.entities.entity_operation_failed_exception import EntityOperationFailedException
 from durabletask.internal import helpers
 from durabletask.internal.entity_state_shim import StateShim
@@ -361,8 +362,13 @@ class TaskHubGrpcWorker:
             Defaults to None.
         secure_channel (bool, optional): Whether to use a secure gRPC channel (TLS).
             Defaults to False.
+        channel (Optional[grpc.Channel], optional): Pre-configured gRPC channel to use.
+            If set, host address, secure_channel, interceptors, and channel_options
+            are ignored when creating connections.
         interceptors (Optional[Sequence[shared.ClientInterceptor]], optional): Custom gRPC
             interceptors to apply to the channel. Defaults to None.
+        channel_options (Optional[GrpcChannelOptions], optional): Extra low-level gRPC
+            channel configuration including retry/service config options.
         concurrency_options (Optional[ConcurrencyOptions], optional): Configuration for
             controlling worker concurrency limits. If None, default settings are used.
 
@@ -426,8 +432,10 @@ class TaskHubGrpcWorker:
             metadata: Optional[list[tuple[str, str]]] = None,
             log_handler: Optional[logging.Handler] = None,
             log_formatter: Optional[logging.Formatter] = None,
+            channel: Optional[grpc.Channel] = None,
             secure_channel: bool = False,
             interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
+            channel_options: Optional[GrpcChannelOptions] = None,
             concurrency_options: Optional[ConcurrencyOptions] = None,
             maximum_timer_interval: Optional[timedelta] = DEFAULT_MAXIMUM_TIMER_INTERVAL,
             payload_store: Optional[PayloadStore] = None,
@@ -439,8 +447,10 @@ class TaskHubGrpcWorker:
         self._logger = shared.get_logger("worker", log_handler, log_formatter)
         self._shutdown = Event()
         self._is_running = False
+        self._channel = channel
         self._secure_channel = secure_channel
         self._payload_store = payload_store
+        self._channel_options = channel_options
 
         # Use provided concurrency options or create default ones
         self._concurrency_options = (
@@ -590,7 +600,7 @@ class TaskHubGrpcWorker:
 
         def create_fresh_connection():
             nonlocal current_channel, current_stub, conn_retry_count
-            if current_channel:
+            if current_channel and self._channel is None:
                 try:
                     current_channel.close()
                 except Exception:
@@ -598,16 +608,22 @@ class TaskHubGrpcWorker:
             current_channel = None
             current_stub = None
             try:
-                current_channel = shared.get_grpc_channel(
-                    self._host_address, self._secure_channel, self._interceptors
-                )
+                if self._channel is not None:
+                    current_channel = self._channel
+                else:
+                    current_channel = shared.get_grpc_channel(
+                        self._host_address,
+                        self._secure_channel,
+                        self._interceptors,
+                        channel_options=self._channel_options,
+                    )
                 current_stub = stubs.TaskHubSidecarServiceStub(current_channel)
                 current_stub.Hello(empty_pb2.Empty())
                 conn_retry_count = 0
                 self._logger.info(f"Created fresh connection to {self._host_address}")
             except Exception as e:
                 self._logger.warning(f"Failed to create connection: {e}")
-                current_channel = None
+                current_channel = self._channel if self._channel is not None else None
                 current_stub = None
                 raise
 
@@ -632,12 +648,12 @@ class TaskHubGrpcWorker:
                 current_reader_thread = None
 
             # Close the channel
-            if current_channel:
+            if current_channel and self._channel is None:
                 try:
                     current_channel.close()
                 except Exception:
                     pass
-            current_channel = None
+            current_channel = self._channel if self._channel is not None else None
             current_stub = None
 
         def should_invalidate_connection(rpc_error):

{durabletask-1.4.0.dev30.dist-info → durabletask-1.4.0.dev32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.4.0.dev30
+Version: 1.4.0.dev32
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.4.0.dev30.dist-info → durabletask-1.4.0.dev32.dist-info}/RECORD

@@ -1,8 +1,10 @@
-durabletask/__init__.py,sha256=OdfKCNlS_NJawRfLWsFNj7YIHeGSQkh2VH3OzG0Oric,644
-durabletask/client.py,sha256=NbIdDTQR7XI_ZiqsGMP0q5vmbe5-ShyGUQre1qgB-Ag,34107
+durabletask/__init__.py,sha256=GhLZFOSOVlP7Jomi6f-nNYiUxDf5a2wNylkBAcshEBA,780
+durabletask/client.py,sha256=PUOTYi0Kw7JoREbz-W8Gw5tjN_VCZxBLMqLq0T97unQ,40086
+durabletask/grpc_options.py,sha256=k1xXnKzK5b_86wibuh7Ype396A-Gs6P4nbHBaUSpE9U,4174
+durabletask/history.py,sha256=VhrWb5eFr9TZSaazpotdMzKt2quwLuJVRk9j39WbTPs,18680
 durabletask/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 durabletask/task.py,sha256=QS7RPUaWhb4Xq5hi7nnueooJqQSDO6ipEoiAiSVkAIs,24009
-durabletask/worker.py,sha256=B8aYoOguNuYccmmtGF9GFr3YEEdfTGJqcOoox0kByQM,133661
+durabletask/worker.py,sha256=ZNx_85fGjgUkjJK_dEI2AZRB4qM3XMV6hgPlc3PPdFk,134691
 durabletask/entities/__init__.py,sha256=DbNd5riqWZaj3tG6gN82O8Q6wTmFpe6QaH0pQgDSPHs,721
 durabletask/entities/durable_entity.py,sha256=LQPWnUlRsHiFVRoTdpeSK--eXtjf2UGbVQwEEKf7QwI,3318
 durabletask/entities/entity_context.py,sha256=U-B3i9QP34N-6Fikx_tMp8zo0YLdmwhwpdxwjHd7z-M,5346
@@ -19,21 +21,22 @@ durabletask/internal/entity_state_shim.py,sha256=Z_LUy7wYKELg3vBvti6hKRthRpfXqwL
 durabletask/internal/exceptions.py,sha256=G1qnH5KReJk04_eewMIr2TTXvdeWDriq-SiAwSahMMs,298
 durabletask/internal/grpc_interceptor.py,sha256=ZWNwIBCy-TzVr4KjuPqzgKsWDHvGPUbwWlw4NF0T4A0,5820
 durabletask/internal/helpers.py,sha256=FVDJypvUmOKKcosRoh8N7rs-UL-ai15KN_IBC-XkU50,12772
+durabletask/internal/history_helpers.py,sha256=myZQoN--CNaJqEr7jGyLJRBd0QvpVtZbxILArASgYow,2463
 durabletask/internal/json_encode_output_exception.py,sha256=y13uVALM5pGQKMHEKy1npKHJgKGAjhAKoUcU-wZGYSg,426
 durabletask/internal/orchestration_entity_context.py,sha256=zggVZ1L1YMm2eSzQy7m6jlag9XkP1DGgZVrZzJmr5yE,5410
 durabletask/internal/orchestrator_service_pb2.py,sha256=K5iG8oguyGhTGt0YmkDsK9ZQz5tt7fFxgaFJKRru0w4,53149
 durabletask/internal/orchestrator_service_pb2.pyi,sha256=TFa752MEoXPdK1fP2fDIIaqpGQJ0sbyXRoNg51hlegE,78590
 durabletask/internal/orchestrator_service_pb2_grpc.py,sha256=Rk0QpGOc8fTeIGULB6xww9CtX6GiLGlZ3JMoZyW9Wuo,60845
 durabletask/internal/proto_task_hub_sidecar_service_stub.py,sha256=pFlOCj1LhuhU5OKU4CZIuQCCsf9jilC9GXDqlEQYQ0U,1503
-durabletask/internal/shared.py,sha256=3GMYHWCFX9esgzlRwNr3J2AOeufAIypTZJQ9n2xI6g4,5589
+durabletask/internal/shared.py,sha256=00NrfM7dmdBQznLt0S9rfWoYWBTOXHWnmg3nemhyWco,6819
 durabletask/internal/tracing.py,sha256=3cSanl0UcmGekItHcQ6tSl7wqSkS7_wOKzsDvJyS_ag,28821
 durabletask/payload/__init__.py,sha256=1h68pQvgk8JUp5LBJuBq9W4GUPYkdlhqmCCQEg6YBYI,784
 durabletask/payload/helpers.py,sha256=RYG5MEVAqHjm4zfFHs3Td91FVQHUoCcb5hbEJ4sYj5s,12350
 durabletask/payload/store.py,sha256=3qJMvKxRUkr6ScWUzxpKAVgzuhFLywRW8a2_5OOmNk4,3000
 durabletask/testing/__init__.py,sha256=rXbcSFtzuaRAbDNX-HmdgbxLTegvKJ1FRjZfSOIAMgA,323
-durabletask/testing/in_memory_backend.py,sha256=ELxyCDRDNOabygIvw9ZeRUpP3MzeM5Hdbu6QlRwKdno,79249
-durabletask-1.4.0.dev30.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
-durabletask-1.4.0.dev30.dist-info/METADATA,sha256=KW-KJvIH_gr4qSOVjEQqq7Il1uNRFMBuV37FMfTF7g0,4404
-durabletask-1.4.0.dev30.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-durabletask-1.4.0.dev30.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
-durabletask-1.4.0.dev30.dist-info/RECORD,,
+durabletask/testing/in_memory_backend.py,sha256=mF0zCA3GMLUd0vqa7CvkgBhYXH4VCsqHReIWuw72wvA,82530
+durabletask-1.4.0.dev32.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+durabletask-1.4.0.dev32.dist-info/METADATA,sha256=6jrrQkmgSTCTRRdoeoFUUKpP0OUVNjB4inn5V4Ua9-M,4404
+durabletask-1.4.0.dev32.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+durabletask-1.4.0.dev32.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
+durabletask-1.4.0.dev32.dist-info/RECORD,,