Fix gaps found via integration tests

Author: andystaples

CHANGELOG.md

@@ -7,6 +7,16 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+ADDED
+
+- Added a `result` property to `Task` as a convenience alias for `get_result()`.
+
+FIXED
+
+- `OrchestrationContext.create_timer` now accepts timezone-aware `datetime`
+  values, normalizing them to UTC instead of raising when compared against the
+  orchestration's internal clock.
+
 ## v1.7.0
 
 ADDED

azure-functions-durable/CHANGELOG.md

@@ -7,8 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Fixed
+
+- `durable_client_input` now injects a rich `DurableFunctionsClient` into the
+  decorated function's client parameter (the binding's JSON string is converted
+  to a client object). Previously the client parameter received the raw string.
+- `DurableFunctionsClient` now applies the host-provided
+  `maxGrpcMessageSizeInBytes` to the gRPC channel's send/receive message limits
+  (when provided), allowing large orchestration payloads to be retrieved. When
+  the host does not supply a value, the gRPC library defaults are left in place.
+- `DurableOrchestrationContext.current_utc_datetime` is now timezone-aware
+  (UTC), matching v1, so comparisons against timezone-aware datetimes (e.g. a
+  parsed scheduled-start time) no longer raise.
+- `DurableOrchestrationStatus.to_json()` now emits orchestration payloads
+  (`output`, `input`, `customStatus`) as their raw JSON representation instead
+  of reconstructed Python objects, so the result is always JSON-serializable
+  even when payloads are custom types.
+
 ### Added
 
+- The `orchestration_trigger` decorator now accepts an `input_type` argument
+  (v1 parity). When set, a v1-style `context.get_input()` decodes the input to
+  that type; a call-site `expected_type` on `get_input` takes precedence.
 - One-argument (Azure Functions / v1-style) entity functions
   (``def entity(context):``) are now supported. The worker detects the entity's
   shape and, for single-argument functions, delivers a functional

azure-functions-durable/azure/durable_functions/client.py

@@ -15,6 +15,7 @@
     OrchestrationStatus,
 )
 from durabletask.entities import EntityInstanceId
+from durabletask.grpc_options import GrpcChannelOptions
 from .internal.azurefunctions_grpc_interceptor import AzureFunctionsAsyncDefaultClientInterceptorImpl
 from .internal.serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 from .http import HttpManagementPayload
@@ -58,13 +59,23 @@ def __init__(self, client_as_string: str):
 
         interceptors = [AzureFunctionsAsyncDefaultClientInterceptorImpl(self.taskHubName, self.requiredQueryStringParameters)]
 
+        # Only override the gRPC message size limits when the host explicitly
+        # provides a value. When unset (0), we leave the gRPC library defaults
+        # in place rather than applying a large default of our own.
+        channel_options: GrpcChannelOptions | None = None
+        if self.maxGrpcMessageSizeInBytes > 0:
+            channel_options = GrpcChannelOptions(
+                max_receive_message_length=self.maxGrpcMessageSizeInBytes,
+                max_send_message_length=self.maxGrpcMessageSizeInBytes)
+
         # We pass in None for the metadata so we don't construct an additional interceptor in the parent class
         # Since the parent class doesn't use anything metadata for anything else, we can set it as None
         super().__init__(
             host_address=self.rpcBaseUrl,
             secure_channel=False,
             metadata=None,
             interceptors=interceptors,
+            channel_options=channel_options,
             data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
 
     def _parse_client_configuration(self, client_as_string: str) -> None:

azure-functions-durable/azure/durable_functions/internal/compat/durable_orchestration_status.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
+import json
 from datetime import datetime
 from typing import Any, Optional
 
@@ -94,7 +95,13 @@ def history(self) -> Optional[list[Any]]:
         return None
 
     def to_json(self) -> dict[str, Any]:
-        """Convert this status into a v1-compatible JSON dictionary."""
+        """Convert this status into a v1-compatible JSON dictionary.
+
+        Payload fields (``output``, ``input``, ``customStatus``) are emitted as
+        their raw JSON representation rather than the reconstructed Python
+        objects, so the result is always JSON-serializable even when the
+        orchestration payloads are custom types.
+        """
         result: dict[str, Any] = {}
         if self.name is not None:
             result["name"] = self.name
@@ -104,12 +111,32 @@ def to_json(self) -> dict[str, Any]:
             result["createdTime"] = self.created_time.isoformat()
         if self.last_updated_time is not None:
             result["lastUpdatedTime"] = self.last_updated_time.isoformat()
-        if self.output is not None:
-            result["output"] = self.output
-        if self.input_ is not None:
-            result["input"] = self.input_
+        output = self._raw_payload(
+            self._state.serialized_output if self._state is not None else None)
+        if output is not None:
+            result["output"] = output
+        input_ = self._raw_payload(
+            self._state.serialized_input if self._state is not None else None)
+        if input_ is not None:
+            result["input"] = input_
         if self.runtime_status is not None:
             result["runtimeStatus"] = self.runtime_status.name
-        if self.custom_status is not None:
-            result["customStatus"] = self.custom_status
+        custom_status = self._raw_payload(
+            self._state.serialized_custom_status if self._state is not None else None)
+        if custom_status is not None:
+            result["customStatus"] = custom_status
         return result
+
+    @staticmethod
+    def _raw_payload(serialized: Optional[str]) -> Any:
+        """Parse a serialized payload as plain JSON without reconstructing types.
+
+        Returns the parsed JSON value (which is always JSON-serializable), or the
+        original string if it is not valid JSON, or ``None`` when absent.
+        """
+        if serialized is None:
+            return None
+        try:
+            return json.loads(serialized)
+        except (TypeError, ValueError):
+            return serialized

azure-functions-durable/azure/durable_functions/internal/compat/orchestration_context.py

@@ -2,7 +2,7 @@
 # Licensed under the MIT License.
 
 import inspect
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Generator, Optional, cast
 from uuid import UUID
 
@@ -61,8 +61,15 @@ def is_replaying(self) -> bool:
 
     @property
     def current_utc_datetime(self) -> datetime:
-        """Get the replay-safe current UTC date/time."""
-        return self._ctx.current_utc_datetime
+        """Get the replay-safe current UTC date/time.
+
+        Returned as a timezone-aware (UTC) datetime for v1 compatibility;
+        durabletask exposes a naive UTC datetime.
+        """
+        value = self._ctx.current_utc_datetime
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value
 
     @property
     def custom_status(self) -> Any:

durabletask/task.py

@@ -503,6 +503,11 @@ def is_failed(self) -> bool:
         """Returns True if the task has failed, False otherwise."""
         return self._exception is not None
 
+    @property
+    def result(self) -> T:
+        """Returns the result of the task (alias for :meth:`get_result`)."""
+        return self.get_result()
+
     def get_result(self) -> T:
         """Returns the result of the task."""
         if not self._is_complete:

durabletask/worker.py

@@ -1668,6 +1668,11 @@ def create_timer_internal(
         else:
             final_fire_at = fire_at
 
+        # Normalize timezone-aware datetimes to naive UTC so they can be safely
+        # compared against and combined with the orchestration's naive UTC clock.
+        if final_fire_at.tzinfo is not None:
+            final_fire_at = final_fire_at.astimezone(timezone.utc).replace(tzinfo=None)
+
         next_fire_at: datetime = final_fire_at
 
         if (

tests/azure-functions-durable/test_client_compat.py

@@ -399,6 +399,9 @@ def _fake_state():
         created_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
         last_updated_at=datetime(2026, 1, 2, tzinfo=timezone.utc),
         runtime_status=OrchestrationStatus.RUNNING,
+        serialized_input='{"in": 1}',
+        serialized_output='{"out": 2}',
+        serialized_custom_status='"cs"',
         get_input=lambda: {"in": 1},
         get_output=lambda: {"out": 2},
         get_custom_status=lambda: "cs",