Azure · dibahlfi · Jun 16, 2026 · Jun 16, 2026 · xinlian12 · Jun 17, 2026
@@ -7,6 +7,7 @@
 #### Breaking Changes
 
 #### Bugs Fixed
+* Fixed per-call `read_timeout`, `connection_timeout`, and `timeout` (operation deadline) being dropped on the metadata calls a query makes before its first page.
 
 #### Other Changes
 

@@ -124,6 +124,11 @@ def build_options(kwargs: dict[str, Any]) -> dict[str, Any]:
         options[Constants.Kwargs.READ_TIMEOUT] = kwargs[Constants.Kwargs.READ_TIMEOUT]
     if Constants.Kwargs.TIMEOUT in kwargs:
         options[Constants.Kwargs.TIMEOUT] = kwargs[Constants.Kwargs.TIMEOUT]
+    # Copy (not pop) so connection_timeout stays in kwargs for the page fetch
+    # and is also placed in options, where the container read, partition-key
+    # ranges, and query plan calls read it.
+    if Constants.Kwargs.CONNECTION_TIMEOUT in kwargs:
+        options[Constants.Kwargs.CONNECTION_TIMEOUT] = kwargs[Constants.Kwargs.CONNECTION_TIMEOUT]
 
 
     options[Constants.OperationStartTime] = time.time()
@@ -1082,6 +1087,71 @@ def _build_properties_cache(properties: dict[str, Any], container_link: str) ->
         "partitionKey": properties.get("partitionKey", None), "container_link": container_link
     }
 
+# The three per-call timeout keys a caller can set on one request. The deadline
+# tuple below adds OperationStartTime to these; the carry helpers iterate that
+# 4-key tuple, not this one.
+_PER_CALL_TIMEOUT_OPTION_KEYS: Tuple[str, ...] = (
+    Constants.Kwargs.READ_TIMEOUT,
+    Constants.Kwargs.CONNECTION_TIMEOUT,
+    Constants.Kwargs.TIMEOUT,
+)
+
+# timeout and OperationStartTime must travel together: the deadline is checked as
+# now - OperationStartTime, which defaults to now when missing, so a metadata call
+# without it would measure from its own start, not the operation's.
+_PER_CALL_DEADLINE_OPTION_KEYS: Tuple[str, ...] = _PER_CALL_TIMEOUT_OPTION_KEYS + (
+    Constants.OperationStartTime,
+)
+
+
+def _carry_per_call_timeout_options(source: Optional[Mapping[str, Any]], destination: dict[str, Any]) -> None:
+    """Copy the per-call timeouts and the operation start time from source into destination.
+
+    Copies read_timeout, connection_timeout, timeout, and OperationStartTime. Only
+    keys present in source are copied, so a timeout the caller did not set stays
+    absent and the request uses the client default instead of None. A None or empty
+    source is a no-op.
+
+    :param source: The request options to read the timeouts from (may be None or empty).
+    :type source: ~collections.abc.Mapping[str, typing.Any] or None
+    :param destination: The options dict to copy the timeouts into.
+    :type destination: dict[str, typing.Any]
+    :return: None
+    :rtype: None
+    """
+    if not source:
+        return
+    for key in _PER_CALL_DEADLINE_OPTION_KEYS:
+        if key in source:
+            destination[key] = source[key]
+
+
+def _copy_per_call_timeouts_to_kwargs(
+        options: Optional[Mapping[str, Any]],
+        kwargs: dict[str, Any]
+) -> None:
+    """Copy the per-call timeouts and the operation start time from options into kwargs.
+
+    Moves read_timeout, connection_timeout, timeout, and OperationStartTime from
+    the request options into the kwargs the request layer reads. A value is copied
+    only when it is set (not None), so an unset timeout falls back to the client
+    default instead of None; setdefault keeps any value already in kwargs.
+
+    :param options: The request options to read the timeouts from (may be None or empty).
+    :type options: ~collections.abc.Mapping[str, typing.Any] or None
+    :param kwargs: The kwargs dict to copy the timeouts into; mutated in place.
+    :type kwargs: dict[str, typing.Any]
+    :return: None
+    :rtype: None
+    """
+    if not options:
+        return
+    for key in _PER_CALL_DEADLINE_OPTION_KEYS:
+        value = options.get(key)
+        if value is not None:
+            kwargs.setdefault(key, value)
+
+
 def format_pk_range_options(query_options: Mapping[str, Any]) -> dict[str, Any]:
     """Formats the partition key range options to be used internally from the query ones.
     :param dict query_options: The query options being used.
@@ -1094,4 +1164,7 @@ def format_pk_range_options(query_options: Mapping[str, Any]) -> dict[str, Any]:
             pk_range_options[Constants.ContainerRID] = query_options[Constants.ContainerRID]
         if "excludedLocations" in query_options:
             pk_range_options["excludedLocations"] = query_options["excludedLocations"]
+        # Keep the per-call timeouts so the partition-key ranges fetch uses them
+        # instead of the client default.
+        _carry_per_call_timeout_options(query_options, pk_range_options)
     return pk_range_options
@@ -116,15 +116,17 @@ class _Constants:
     class Kwargs:
         """Keyword arguments used in the azure-cosmos package"""
 
+        # Whether to retry write operations if they fail. Used either at client level or request level.
         RETRY_WRITE: Literal["retry_write"] = "retry_write"
-        """Whether to retry write operations if they fail. Used either at client level or request level."""
         EXCLUDED_LOCATIONS: Literal["excludedLocations"] = "excludedLocations"
+        # Availability strategy config. Used either at client level or request level.
         AVAILABILITY_STRATEGY: Literal["availabilityStrategy"] = "availabilityStrategy"
-        """Availability strategy config. Used either at client level or request level"""
+        # Socket read timeout in seconds. Used either at client level or request level.
         READ_TIMEOUT: Literal["read_timeout"] = "read_timeout"
-        """Socket read timeout in seconds. Used either at client level or request level."""
+        # Absolute timeout in seconds for the combined HTTP request and response processing.
         TIMEOUT: Literal["timeout"] = "timeout"
-        """Absolute timeout in seconds for the combined HTTP request and response processing."""
+        # Socket connect (handshake) timeout in seconds. Used either at client level or request level.
+        CONNECTION_TIMEOUT: Literal["connection_timeout"] = "connection_timeout"
 
     class UserAgentFeatureFlags(IntEnum):
         """

@@ -3244,18 +3244,11 @@ def __QueryFeed(  # pylint: disable=too-many-locals, too-many-statements, too-ma
         """
         if options is None:
             options = {}
-        read_timeout = options.get("read_timeout")
-        if read_timeout is not None:
-            # we currently have a gap where kwargs are not getting passed correctly down the pipeline. In order to make
-            # absolute time out work, we are passing read_timeout via kwargs as a temporary fix
-            kwargs.setdefault("read_timeout", read_timeout)
-
-        operation_start_time = options.get(Constants.OperationStartTime)
-        if operation_start_time is not None:
-            kwargs.setdefault(Constants.OperationStartTime, operation_start_time)
-        timeout = options.get("timeout")
-        if timeout is not None:
-            kwargs.setdefault("timeout", timeout)
+        # Copy the per-call timeouts and the operation start time out of options into
+        # kwargs, where _Request reads them. A value is copied only when set, so
+        # an unset timeout falls back to the client/policy default instead of
+        # None; setdefault keeps any explicit kwarg the caller already placed.
+        base._copy_per_call_timeouts_to_kwargs(options, kwargs)
 
         # Execution context injects this via request options; keep kwargs fallback
         # for compatibility with call paths that still thread internal values there.

@@ -35,6 +35,7 @@
 from azure.cosmos.exceptions import CosmosHttpResponseError
 from azure.cosmos.http_constants import StatusCodes
 from ..._constants import _Constants as Constants
+from ... import _base
 
 # pylint: disable=protected-access
 
@@ -67,11 +68,16 @@ def __init__(self, client, resource_link, query, options, fetch_function,
     async def _create_execution_context_with_query_plan(self):
         self._fetched_query_plan = True
         query_to_use = self._query if self._query is not None else "Select * from root r"
+        # Forward the per-call timeouts and OperationStartTime only when the caller
+        # set them, so an unset value falls back to the client/policy default
+        # instead of overriding it with None.
+        query_plan_kwargs = {}
+        _base._copy_per_call_timeouts_to_kwargs(self._options, query_plan_kwargs)
         query_plan = await self._client._GetQueryPlanThroughGateway(
             query_to_use,
             self._resource_link,
             self._options.get('excludedLocations'),
-            read_timeout=self._options.get('read_timeout')
+            **query_plan_kwargs
         )
         query_execution_info = _PartitionedQueryExecutionInfo(query_plan)
         qe_info = getattr(query_execution_info, "_query_execution_info", None)

@@ -10,6 +10,7 @@
     _FULL_TEXT_SCORE_SCOPE_KEY, _FULL_TEXT_SCORE_SCOPE_LOCAL, _FULL_TEXT_SCORE_SCOPE_DEFAULT
 from azure.cosmos._routing import routing_range
 from azure.cosmos import exceptions
+from azure.cosmos import _base
 from ..._constants import _Constants as Constants
 
 # pylint: disable=protected-access
@@ -297,6 +298,9 @@ async def _get_target_partition_key_range(self, target_all_ranges):
             feed_options = {}
             if Constants.ContainerRID in self._options:
                 feed_options[Constants.ContainerRID] = self._options[Constants.ContainerRID]
+            # This path calls _ReadPartitionKeyRanges directly and skips
+            # format_pk_range_options, so copy the per-call timeouts here too.
+            _base._carry_per_call_timeout_options(self._options, feed_options)
             return [item async for item in self._client._ReadPartitionKeyRanges(
                 collection_link=self._resource_link, feed_options=feed_options)]
         query_ranges = self._partitioned_query_ex_info.get_query_ranges()

@@ -34,6 +34,7 @@
 from azure.cosmos.documents import _DistinctType
 from azure.cosmos.http_constants import StatusCodes, SubStatusCodes
 from .._constants import _Constants as Constants
+from .. import _base
 
 # pylint: disable=protected-access
 
@@ -97,11 +98,16 @@ def __init__(self, client, resource_link, query, options, fetch_function, respon
     def _create_execution_context_with_query_plan(self):
         self._fetched_query_plan = True
         query_to_use = self._query if self._query is not None else "Select * from root r"
+        # Forward the per-call timeouts and OperationStartTime only when the caller
+        # set them, so an unset value falls back to the client/policy default
+        # instead of overriding it with None.
+        query_plan_kwargs = {}
+        _base._copy_per_call_timeouts_to_kwargs(self._options, query_plan_kwargs)
         query_plan = self._client._GetQueryPlanThroughGateway(
             query_to_use,
             self._resource_link,
             self._options.get('excludedLocations'),
-            read_timeout=self._options.get('read_timeout')
+            **query_plan_kwargs
         )
         query_execution_info = _PartitionedQueryExecutionInfo(query_plan)
         qe_info = getattr(query_execution_info, "_query_execution_info", None)

@@ -8,6 +8,7 @@
 from azure.cosmos._execution_context import document_producer
 from azure.cosmos._routing import routing_range
 from azure.cosmos import exceptions
+from azure.cosmos import _base
 from .._constants import _Constants as Constants
 
 # pylint: disable=protected-access
@@ -454,6 +455,9 @@ def _get_target_partition_key_range(self, target_all_ranges):
             feed_options = {}
             if Constants.ContainerRID in self._options:
                 feed_options[Constants.ContainerRID] = self._options[Constants.ContainerRID]
+            # This path calls _ReadPartitionKeyRanges directly and skips
+            # format_pk_range_options, so copy the per-call timeouts here too.
+            _base._carry_per_call_timeout_options(self._options, feed_options)
             return list(self._client._ReadPartitionKeyRanges(
                 collection_link=self._resource_link, feed_options=feed_options))
         query_ranges = self._partitioned_query_ex_info.get_query_ranges()

@@ -39,7 +39,8 @@
 from .. import _utils as utils
 from .._availability_strategy_config import _validate_request_hedging_strategy
 from .._base import (_build_properties_cache, _deserialize_throughput, _replace_throughput,
-                     build_options as _build_options, GenerateGuidId, validate_cache_staleness_value)
+                     build_options as _build_options, _copy_per_call_timeouts_to_kwargs,
+                     GenerateGuidId, validate_cache_staleness_value)
 from .._change_feed.feed_range_internal import FeedRangeInternalEpk
 
 from .._cosmos_responses import CosmosDict, CosmosList, CosmosAsyncItemPaged
@@ -102,13 +103,9 @@ async def _get_properties_with_options(self, options: Optional[dict[str, Any]] =
         if options:
             if "excludedLocations" in options:
                 kwargs['excluded_locations'] = options['excludedLocations']
-            if Constants.OperationStartTime in options:
-                kwargs[Constants.OperationStartTime] = options[Constants.OperationStartTime]
-            if Constants.Kwargs.TIMEOUT in options:
-                kwargs[Constants.Kwargs.TIMEOUT] = options[Constants.Kwargs.TIMEOUT]
-            if Constants.Kwargs.READ_TIMEOUT in options:
-                kwargs[Constants.Kwargs.READ_TIMEOUT] = options[Constants.Kwargs.READ_TIMEOUT]
-
+            # Forward the per-call timeouts and the operation start time so the
+            # container read honors them instead of the client/policy default.
+            _copy_per_call_timeouts_to_kwargs(options, kwargs)
         return await self._get_properties(**kwargs)
 
     async def _get_properties(self, **kwargs: Any) -> dict[str, Any]:

@@ -3038,20 +3038,11 @@ async def __QueryFeed(  # pylint: disable=too-many-branches,too-many-statements,
         if options is None:
             options = {}
 
-        read_timeout = options.get("read_timeout")
-        if read_timeout is not None:
-            # we currently have a gap where kwargs are not getting passed correctly down the pipeline. In order to make
-            # absolute time out work, we are passing read_timeout via kwargs as a temporary fix
-            kwargs.setdefault("read_timeout", read_timeout)
-
-        operation_start_time = options.get(Constants.OperationStartTime)
-        if operation_start_time is not None:
-            # we need to set operation_state in kwargs as thats where it is looked at while sending the request
-            kwargs.setdefault(Constants.OperationStartTime, operation_start_time)
-        timeout = options.get("timeout")
-        if timeout is not None:
-            # we need to set operation_state in kwargs as that's where it is looked at while sending the request
-            kwargs.setdefault("timeout", timeout)
+        # Copy the per-call timeouts and the operation start time out of options into
+        # kwargs, where _Request reads them. A value is copied only when set, so
+        # an unset timeout falls back to the client/policy default instead of
+        # None; setdefault keeps any explicit kwarg the caller already placed.
+        base._copy_per_call_timeouts_to_kwargs(options, kwargs)
 
         # The capture dict can arrive via two upstream paths:
         #   1. The query execution context puts it into ``options`` (the

@@ -140,11 +140,13 @@ async def ExecuteAsync(client, global_endpoint_manager, function, *args, **kwarg
                 await _record_success_if_request_not_cancelled(args[0], global_endpoint_manager, pk_range_wrapper)
             else:
                 result = await ExecuteFunctionAsync(function, *args, **kwargs)
-                # Check timeout after successful execution
-                if timeout:
-                    elapsed = time.time() - operation_start_time
-                    if elapsed >= timeout:
-                        raise exceptions.CosmosClientTimeoutError(error=last_error)
+            # Check the deadline after a successful call. Outside the if/else so it
+            # also covers the normal request path (if args), matching the sync loop:
+            # a call that succeeds after the deadline passed must still raise.
+            if timeout:
+                elapsed = time.time() - operation_start_time
+                if elapsed >= timeout:
+                    raise exceptions.CosmosClientTimeoutError(error=last_error)
             if not client.last_response_headers:
                 client.last_response_headers = {}
 

@@ -35,7 +35,7 @@
 from . import _utils as utils
 from ._availability_strategy_config import _validate_request_hedging_strategy
 from ._base import (_build_properties_cache, _deserialize_throughput, _replace_throughput, build_options,
-                    GenerateGuidId, validate_cache_staleness_value)
+                    _copy_per_call_timeouts_to_kwargs, GenerateGuidId, validate_cache_staleness_value)
 from ._change_feed.feed_range_internal import FeedRangeInternalEpk
 from ._constants import _Constants as Constants, TimeoutScope
 from ._cosmos_client_connection import CosmosClientConnection
@@ -103,12 +103,9 @@ def _get_properties_with_options(self, options: Optional[dict[str, Any]] = None)
         if options:
             if "excludedLocations" in options:
                 kwargs['excluded_locations'] = options['excludedLocations']
-            if Constants.OperationStartTime in options:
-                kwargs[Constants.OperationStartTime] = options[Constants.OperationStartTime]
-            if Constants.Kwargs.TIMEOUT in options:
-                kwargs[Constants.Kwargs.TIMEOUT] = options[Constants.Kwargs.TIMEOUT]
-            if Constants.Kwargs.READ_TIMEOUT in options:
-                kwargs[Constants.Kwargs.READ_TIMEOUT] = options[Constants.Kwargs.READ_TIMEOUT]
+            # Forward the per-call timeouts and the operation start time so the
+            # container read honors them instead of the client/policy default.
+            _copy_per_call_timeouts_to_kwargs(options, kwargs)
         return self._get_properties(**kwargs)
 
     def _get_properties(self, **kwargs: Any) -> dict[str, Any]: