azure-functions-durable 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

azure/durable_functions/decorators/durable_app.py

@@ -195,7 +195,14 @@ class Blueprint(TriggerApi, BindingApi, SettingsApi):
             # construct rich object from it,
             # and assign parameter to that rich object
             starter = kwargs[parameter_name]
-            client = client_constructor(starter)
+
+            # Try to extract the function invocation ID from the context for correlation
+            function_invocation_id = None
+            context = kwargs.get('context')
+            if context is not None and hasattr(context, 'invocation_id'):
+                function_invocation_id = context.invocation_id
+
+            client = client_constructor(starter, function_invocation_id)
             kwargs[parameter_name] = client
 
             # Invoke user code with rich DF Client binding

azure/durable_functions/models/DurableOrchestrationClient.py

@@ -26,7 +26,16 @@ class DurableOrchestrationClient:
     orchestration instances.
     """
 
-    def __init__(self, context: str):
+    def __init__(self, context: str, function_invocation_id: Optional[str] = None):
+        """Initialize a DurableOrchestrationClient.
+
+        Parameters
+        ----------
+        context : str
+            The JSON-encoded client binding context.
+        function_invocation_id : Optional[str]
+            The function invocation ID for correlation with host-side logs.
+        """
         self.task_hub_name: str
         self._uniqueWebHookOrigins: List[str]
         self._event_name_placeholder: str = "{eventName}"
@@ -39,6 +48,7 @@ class DurableOrchestrationClient:
         self._show_history_query_key: str = "showHistory"
         self._show_history_output_query_key: str = "showHistoryOutput"
         self._show_input_query_key: str = "showInput"
+        self._function_invocation_id: Optional[str] = function_invocation_id
         self._orchestration_bindings: DurableOrchestrationBindings = \
             DurableOrchestrationBindings.from_json(context)
         self._post_async_request = post_async_request
@@ -48,7 +58,8 @@ class DurableOrchestrationClient:
     async def start_new(self,
                         orchestration_function_name: str,
                         instance_id: Optional[str] = None,
-                        client_input: Optional[Any] = None) -> str:
+                        client_input: Optional[Any] = None,
+                        version: Optional[str] = None) -> str:
         """Start a new instance of the specified orchestrator function.
 
         If an orchestration instance with the specified ID already exists, the
@@ -63,6 +74,9 @@ class DurableOrchestrationClient:
             the Durable Functions extension will generate a random GUID (recommended).
         client_input : Optional[Any]
             JSON-serializable input value for the orchestrator function.
+        version : Optional[str]
+            The version to assign to the orchestration instance. If not specified,
+            the defaultVersion from host.json will be used.
 
         Returns
         -------
@@ -70,7 +84,9 @@ class DurableOrchestrationClient:
             The ID of the new orchestration instance if successful, None if not.
         """
         request_url = self._get_start_new_url(
-            instance_id=instance_id, orchestration_function_name=orchestration_function_name)
+            instance_id=instance_id,
+            orchestration_function_name=orchestration_function_name,
+            version=version)
 
         trace_parent, trace_state = DurableOrchestrationClient._get_current_activity_context()
 
@@ -78,7 +94,8 @@ class DurableOrchestrationClient:
             request_url,
             self._get_json_input(client_input),
             trace_parent,
-            trace_state)
+            trace_state,
+            self._function_invocation_id)
 
         status_code: int = response[0]
         if status_code <= 202 and response[1]:
@@ -250,7 +267,10 @@ class DurableOrchestrationClient:
         request_url = self._get_raise_event_url(
             instance_id, event_name, task_hub_name, connection_name)
 
-        response = await self._post_async_request(request_url, json.dumps(event_data))
+        response = await self._post_async_request(
+            request_url,
+            json.dumps(event_data),
+            function_invocation_id=self._function_invocation_id)
 
         switch_statement = {
             202: lambda: None,
@@ -439,7 +459,10 @@ class DurableOrchestrationClient:
         """
         request_url = f"{self._orchestration_bindings.rpc_base_url}instances/{instance_id}/" \
                       f"terminate?reason={quote(reason)}"
-        response = await self._post_async_request(request_url, None)
+        response = await self._post_async_request(
+            request_url,
+            None,
+            function_invocation_id=self._function_invocation_id)
         switch_statement = {
             202: lambda: None,  # instance in progress
             410: lambda: None,  # instance failed or terminated
@@ -558,7 +581,8 @@ class DurableOrchestrationClient:
             request_url,
             json.dumps(operation_input) if operation_input else None,
             trace_parent,
-            trace_state)
+            trace_state,
+            self._function_invocation_id)
 
         switch_statement = {
             202: lambda: None  # signal accepted
@@ -639,10 +663,15 @@ class DurableOrchestrationClient:
             raise Exception(result)
 
     def _get_start_new_url(
-            self, instance_id: Optional[str], orchestration_function_name: str) -> str:
+            self, instance_id: Optional[str], orchestration_function_name: str,
+            version: Optional[str] = None) -> str:
         instance_path = f'/{instance_id}' if instance_id is not None else ''
         request_url = f'{self._orchestration_bindings.rpc_base_url}orchestrators/' \
                       f'{orchestration_function_name}{instance_path}'
+
+        if version is not None:
+            request_url += f'?version={quote(version)}'
+
         return request_url
 
     def _get_raise_event_url(
@@ -703,7 +732,10 @@ class DurableOrchestrationClient:
             raise Exception("The Python SDK only supports RPC endpoints."
                             + "Please remove the `localRpcEnabled` setting from host.json")
 
-        response = await self._post_async_request(request_url, None)
+        response = await self._post_async_request(
+            request_url,
+            None,
+            function_invocation_id=self._function_invocation_id)
         status: int = response[0]
         ex_msg: str = ""
         if status == 200 or status == 202:
@@ -742,7 +774,10 @@ class DurableOrchestrationClient:
         """
         request_url = f"{self._orchestration_bindings.rpc_base_url}instances/{instance_id}/" \
                       f"suspend?reason={quote(reason)}"
-        response = await self._post_async_request(request_url, None)
+        response = await self._post_async_request(
+            request_url,
+            None,
+            function_invocation_id=self._function_invocation_id)
         switch_statement = {
             202: lambda: None,  # instance is suspended
             410: lambda: None,  # instance completed
@@ -777,7 +812,10 @@ class DurableOrchestrationClient:
         """
         request_url = f"{self._orchestration_bindings.rpc_base_url}instances/{instance_id}/" \
                       f"resume?reason={quote(reason)}"
-        response = await self._post_async_request(request_url, None)
+        response = await self._post_async_request(
+            request_url,
+            None,
+            function_invocation_id=self._function_invocation_id)
         switch_statement = {
             202: lambda: None,  # instance is resumed
             410: lambda: None,  # instance completed

azure/durable_functions/models/DurableOrchestrationContext.py

@@ -246,8 +246,10 @@ class DurableOrchestrationContext:
             The HTTP request method.
         uri: str
             The HTTP request uri.
-        content: Optional[str]
-            The HTTP request content.
+        content: str or dict, optional
+            The HTTP request content. Can be a string or a JSON-serializable dictionary.
+            Note: Although the type hint says 'str', a dictionary is accepted
+            and will be serialized to JSON.
         headers: Optional[Dict[str, str]]
             The HTTP request headers.
         token_source: TokenSource
@@ -285,7 +287,8 @@ class DurableOrchestrationContext:
 
     def call_sub_orchestrator(self,
                               name: Union[str, Callable], input_: Optional[Any] = None,
-                              instance_id: Optional[str] = None) -> TaskBase:
+                              instance_id: Optional[str] = None,
+                              version: Optional[str] = None) -> TaskBase:
         """Schedule sub-orchestration function named `name` for execution.
 
         Parameters
@@ -296,6 +299,9 @@ class DurableOrchestrationContext:
             The JSON-serializable input to pass to the orchestrator function.
         instance_id: Optional[str]
             A unique ID to use for the sub-orchestration instance.
+        version: Optional[str]
+            The version to assign to the sub-orchestration instance. If not specified,
+            the defaultVersion from host.json will be used.
 
         Returns
         -------
@@ -313,14 +319,15 @@ class DurableOrchestrationContext:
         if isinstance(name, FunctionBuilder):
             name = self._get_function_name(name, OrchestrationTrigger)
 
-        action = CallSubOrchestratorAction(name, input_, instance_id)
+        action = CallSubOrchestratorAction(name, input_, instance_id, version)
         task = self._generate_task(action)
         return task
 
     def call_sub_orchestrator_with_retry(self,
                                          name: Union[str, Callable], retry_options: RetryOptions,
                                          input_: Optional[Any] = None,
-                                         instance_id: Optional[str] = None) -> TaskBase:
+                                         instance_id: Optional[str] = None,
+                                         version: Optional[str] = None) -> TaskBase:
         """Schedule sub-orchestration function named `name` for execution, with retry-options.
 
         Parameters
@@ -333,6 +340,9 @@ class DurableOrchestrationContext:
             The JSON-serializable input to pass to the activity function. Defaults to None.
         instance_id: str
             The instance ID of the sub-orchestrator to call.
+        version: Optional[str]
+            The version to assign to the sub-orchestration instance. If not specified,
+            the defaultVersion from host.json will be used.
 
         Returns
         -------
@@ -350,7 +360,8 @@ class DurableOrchestrationContext:
         if isinstance(name, FunctionBuilder):
             name = self._get_function_name(name, OrchestrationTrigger)
 
-        action = CallSubOrchestratorWithRetryAction(name, retry_options, input_, instance_id)
+        action = CallSubOrchestratorWithRetryAction(
+            name, retry_options, input_, instance_id, version)
         task = self._generate_task(action, retry_options)
         return task
 

azure/durable_functions/models/TaskOrchestrationExecutor.py

@@ -276,7 +276,7 @@ class TaskOrchestrationExecutor:
             message contains in it the string representation of the orchestration's
             state
         """
-        if(self.output is not None):
+        if (self.output is not None):
             try:
                 # Attempt to serialize the output. If serialization fails, raise an
                 # error indicating that the orchestration output is not serializable,

azure/durable_functions/models/actions/CallSubOrchestratorAction.py

@@ -11,10 +11,11 @@ class CallSubOrchestratorAction(Action):
     """Defines the structure of the Call SubOrchestrator object."""
 
     def __init__(self, function_name: str, _input: Optional[Any] = None,
-                 instance_id: Optional[str] = None):
+                 instance_id: Optional[str] = None, version: Optional[str] = None):
         self.function_name: str = function_name
         self._input: str = dumps(_input, default=_serialize_custom_object)
         self.instance_id: Optional[str] = instance_id
+        self.version: Optional[str] = version
 
         if not self.function_name:
             raise ValueError("function_name cannot be empty")
@@ -37,4 +38,5 @@ class CallSubOrchestratorAction(Action):
         add_attrib(json_dict, self, 'function_name', 'functionName')
         add_attrib(json_dict, self, '_input', 'input')
         add_attrib(json_dict, self, 'instance_id', 'instanceId')
+        add_attrib(json_dict, self, 'version', 'version')
         return json_dict

azure/durable_functions/models/actions/CallSubOrchestratorWithRetryAction.py

@@ -13,11 +13,12 @@ class CallSubOrchestratorWithRetryAction(Action):
 
     def __init__(self, function_name: str, retry_options: RetryOptions,
                  _input: Optional[Any] = None,
-                 instance_id: Optional[str] = None):
+                 instance_id: Optional[str] = None, version: Optional[str] = None):
         self.function_name: str = function_name
         self._input: str = dumps(_input, default=_serialize_custom_object)
         self.retry_options: RetryOptions = retry_options
         self.instance_id: Optional[str] = instance_id
+        self.version: Optional[str] = version
 
         if not self.function_name:
             raise ValueError("function_name cannot be empty")
@@ -41,4 +42,5 @@ class CallSubOrchestratorWithRetryAction(Action):
         add_attrib(json_dict, self, '_input', 'input')
         add_json_attrib(json_dict, self, 'retry_options', 'retryOptions')
         add_attrib(json_dict, self, 'instance_id', 'instanceId')
+        add_attrib(json_dict, self, 'version', 'version')
         return json_dict

azure/durable_functions/models/utils/http_utils.py

@@ -1,12 +1,87 @@
-from typing import Any, List, Union
+from typing import Any, List, Union, Optional
+import asyncio
 
 import aiohttp
 
 
+# Global session and lock for thread-safe initialization
+_client_session: Optional[aiohttp.ClientSession] = None
+_session_lock: asyncio.Lock = asyncio.Lock()
+
+
+async def _get_session() -> aiohttp.ClientSession:
+    """Get or create the shared ClientSession.
+
+    Returns
+    -------
+    aiohttp.ClientSession
+        The shared client session with configured timeout and connection pooling.
+    """
+    global _client_session
+
+    # Double-check locking pattern for async
+    if _client_session is None or _client_session.closed:
+        async with _session_lock:
+            # Check again after acquiring lock
+            if _client_session is None or _client_session.closed:
+                # Configure timeout optimized for localhost IPC
+                timeout = aiohttp.ClientTimeout(
+                    total=240,  # 4-minute total timeout for slow operations
+                    sock_connect=10,  # Fast connection over localhost
+                    sock_read=None  # Covered by total timeout
+                )
+
+                # Configure TCP connector optimized for localhost IPC
+                connector = aiohttp.TCPConnector(
+                    limit=30,  # Maximum connections for single host
+                    limit_per_host=30,  # Maximum connections per host
+                    enable_cleanup_closed=True  # Enable cleanup of closed connections
+                )
+
+                _client_session = aiohttp.ClientSession(
+                    timeout=timeout,
+                    connector=connector
+                )
+
+    return _client_session
+
+
+async def _handle_request_error():
+    """Handle connection errors by closing and resetting the session.
+
+    This handles cases where the remote host process recycles.
+    """
+    global _client_session
+    async with _session_lock:
+        if _client_session is not None and not _client_session.closed:
+            try:
+                await _client_session.close()
+            finally:
+                _client_session = None
+
+
+async def _close_session() -> None:
+    """Close the shared ClientSession if it exists.
+
+    Note: This function is currently only called by _handle_request_error().
+    There is no worker shutdown hook available, but process shutdown will
+    clean up all resources automatically.
+    """
+    global _client_session
+
+    async with _session_lock:
+        if _client_session is not None and not _client_session.closed:
+            try:
+                await _client_session.close()
+            finally:
+                _client_session = None
+
+
 async def post_async_request(url: str,
                              data: Any = None,
                              trace_parent: str = None,
-                             trace_state: str = None) -> List[Union[int, Any]]:
+                             trace_state: str = None,
+                             function_invocation_id: str = None) -> List[Union[int, Any]]:
     """Post request with the data provided to the url provided.
 
     Parameters
@@ -19,18 +94,24 @@ async def post_async_request(url: str,
         traceparent header to send with the request
     trace_state: str
         tracestate header to send with the request
+    function_invocation_id: str
+        function invocation ID header to send for correlation
 
     Returns
     -------
     [int, Any]
         Tuple with the Response status code and the data returned from the request
     """
-    async with aiohttp.ClientSession() as session:
-        headers = {}
-        if trace_parent:
-            headers["traceparent"] = trace_parent
-        if trace_state:
-            headers["tracestate"] = trace_state
+    session = await _get_session()
+    headers = {}
+    if trace_parent:
+        headers["traceparent"] = trace_parent
+    if trace_state:
+        headers["tracestate"] = trace_state
+    if function_invocation_id:
+        headers["X-Azure-Functions-InvocationId"] = function_invocation_id
+
+    try:
         async with session.post(url, json=data, headers=headers) as response:
             # We disable aiohttp's input type validation
             # as the server may respond with alternative
@@ -38,43 +119,71 @@ async def post_async_request(url: str,
             # More here: https://docs.aiohttp.org/en/stable/client_advanced.html
             data = await response.json(content_type=None)
             return [response.status, data]
+    except (aiohttp.ClientError, asyncio.TimeoutError):
+        # On connection errors, close and recreate session for next request
+        await _handle_request_error()
+        raise
 
 
-async def get_async_request(url: str) -> List[Any]:
+async def get_async_request(url: str,
+                            function_invocation_id: str = None) -> List[Any]:
     """Get the data from the url provided.
 
     Parameters
     ----------
     url: str
         url to get the data from
+    function_invocation_id: str
+        function invocation ID header to send for correlation
 
     Returns
     -------
     [int, Any]
         Tuple with the Response status code and the data returned from the request
     """
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url) as response:
+    session = await _get_session()
+    headers = {}
+    if function_invocation_id:
+        headers["X-Azure-Functions-InvocationId"] = function_invocation_id
+
+    try:
+        async with session.get(url, headers=headers) as response:
             data = await response.json(content_type=None)
             if data is None:
                 data = ""
             return [response.status, data]
+    except (aiohttp.ClientError, asyncio.TimeoutError):
+        # On connection errors, close and recreate session for next request
+        await _handle_request_error()
+        raise
 
 
-async def delete_async_request(url: str) -> List[Union[int, Any]]:
+async def delete_async_request(url: str,
+                               function_invocation_id: str = None) -> List[Union[int, Any]]:
     """Delete the data from the url provided.
 
     Parameters
     ----------
     url: str
         url to delete the data from
+    function_invocation_id: str
+        function invocation ID header to send for correlation
 
     Returns
     -------
     [int, Any]
         Tuple with the Response status code and the data returned from the request
     """
-    async with aiohttp.ClientSession() as session:
-        async with session.delete(url) as response:
+    session = await _get_session()
+    headers = {}
+    if function_invocation_id:
+        headers["X-Azure-Functions-InvocationId"] = function_invocation_id
+
+    try:
+        async with session.delete(url, headers=headers) as response:
             data = await response.json(content_type=None)
             return [response.status, data]
+    except (aiohttp.ClientError, asyncio.TimeoutError):
+        # On connection errors, close and recreate session for next request
+        await _handle_request_error()
+        raise

{azure_functions_durable-1.4.0.dist-info → azure_functions_durable-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-functions-durable
-Version: 1.4.0
+Version: 1.5.0
 Summary: Durable Functions For Python
 Home-page: https://github.com/Azure/azure-functions-durable-python
 Author: Azure Functions team at Microsoft Corp.
@@ -20,7 +20,7 @@ Requires-Python: >=3.9,<4
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: azure-functions>=1.12.0
-Requires-Dist: aiohttp>=3.12.14
+Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: requests==2.*
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: furl>=2.1.0
@@ -58,7 +58,7 @@ Follow these instructions to get started with Durable Functions in Python:
 
 * Python Durable Functions requires [Azure Functions Core Tools](https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local) version 3.0.2630 or higher.
 
-## OpenAI Agents Integration for Reliability on Azure Functions (Preview)
+## OpenAI Agent SDK Integration with Azure Durable Functions (Preview)
 
 Build resilient, stateful AI agents backed by Durable Functions orchestration—see the full documentation at [docs/openai_agents/README.md](docs/openai_agents/README.md).
 

{azure_functions_durable-1.4.0.dist-info → azure_functions_durable-1.5.0.dist-info}/RECORD

@@ -3,13 +3,13 @@ azure/durable_functions/constants.py,sha256=JtknDhaVihMeo-ygY9QNofiO2KEqnQvopdfZ
 azure/durable_functions/entity.py,sha256=mUUzb1BZiDrUJjvxOTlnVURnKPyDGPJ3mXXMN0DKT7M,4649
 azure/durable_functions/orchestrator.py,sha256=SZni90Aweq0OZykHyMblfJpUndJ2woJmySarcsDiIK4,2554
 azure/durable_functions/decorators/__init__.py,sha256=wEubgP2rUUISwidZWgKx6mmzEeGKsSnpGmetjIUi1nw,150
-azure/durable_functions/decorators/durable_app.py,sha256=5ajbhMPKvZKZhYLCxsEn8J4sZO6Pql9j0nOTCxDaMuY,12599
+azure/durable_functions/decorators/durable_app.py,sha256=swk5Bn9r6OiojnSDQQab83KPTVLmwtknCYA24bUL31E,12944
 azure/durable_functions/decorators/metadata.py,sha256=p91rdCe6OSRYJaKAXnrfR0QCV3PoHK7aGy1m6WAnPIE,2828
 azure/durable_functions/models/DurableEntityContext.py,sha256=cyZmjjZu18oV9S4A2NpnXfjd1JQxPxp9EMmAR424UK0,5830
 azure/durable_functions/models/DurableHttpRequest.py,sha256=a5kgRdg4eA0sgyDcpmQWc0dbwP-o3BwWW2Ive0BYO_Q,2021
 azure/durable_functions/models/DurableOrchestrationBindings.py,sha256=_hp61WjN3bQYCqYFQuvUaDdRu7C14fPg7lFbaA9TRe4,2408
-azure/durable_functions/models/DurableOrchestrationClient.py,sha256=kQBqeKugvi2mi-7dDbCxlu67r20doEhDknlchYxcLBE,33018
-azure/durable_functions/models/DurableOrchestrationContext.py,sha256=fZNbUisN9vkublT2L7wYbj0CNfQNOyYcqRwZ9T-SgN8,32090
+azure/durable_functions/models/DurableOrchestrationClient.py,sha256=C07slwFZUxieHUqhbLL6Rdjb1OdN5aho0EPFsHWDDyg,34418
+azure/durable_functions/models/DurableOrchestrationContext.py,sha256=QHh1i-UG5VoG9z0wMvlFMYL8Ye-nOPMm37p8Is6vCWs,32802
 azure/durable_functions/models/DurableOrchestrationStatus.py,sha256=BXWz9L7np4Q9k6z4NsfLX97i2U2IFh94TVeRSV2BjM4,6049
 azure/durable_functions/models/EntityStateResponse.py,sha256=f48W8gmlb-D5iJw3eDyUMYVwHpmIxP6k6a7o2TRHwII,674
 azure/durable_functions/models/FunctionContext.py,sha256=4gHTmIo8DZN-bZLM-hyjoQFlv-AbsfLMT1_X4WxWxqY,274
@@ -20,7 +20,7 @@ azure/durable_functions/models/ReplaySchema.py,sha256=85YZD-QWgMQSfZsRQlfQfLPzK9
 azure/durable_functions/models/RetryOptions.py,sha256=-rmv3mQmzQ_2utFy1d-ontqpcgP139B8MQroanfN54w,1988
 azure/durable_functions/models/RpcManagementOptions.py,sha256=aEOWx_xUWl4Rwb2-7kpyml8rzTX9Vl4s71LkqYPLnHw,3482
 azure/durable_functions/models/Task.py,sha256=e548_wfJkYY_UCpJkwqVVM65tyP6jchox_YNsf8SslM,19559
-azure/durable_functions/models/TaskOrchestrationExecutor.py,sha256=PBbS3aEKn1JCFhvjR9oz4-WmIW_9vh6-ILzImxVN7zw,16085
+azure/durable_functions/models/TaskOrchestrationExecutor.py,sha256=BAwX-sm3aqcPYtSc0i0IQwF6cvQZblsELw_enpADTyY,16086
 azure/durable_functions/models/TokenSource.py,sha256=9uLxiOV8lcDj--3tD0XxcQnigk9AozjdOoJyskctErU,1822
 azure/durable_functions/models/__init__.py,sha256=L7ynxb_mBGCvV1iEAfpJU9_b-8ubKIEJKaZa2aoqjek,999
 azure/durable_functions/models/actions/Action.py,sha256=0jp-SP_12YmZWWctOXmwl48Ozw3dMMq5-crUAkK8Qk0,598
@@ -29,8 +29,8 @@ azure/durable_functions/models/actions/CallActivityAction.py,sha256=G9O9JML-Z0_A
 azure/durable_functions/models/actions/CallActivityWithRetryAction.py,sha256=0dG-NR1YQjiisNhbTsAxG7hCQZBwoJoD8b3B4iuQlmE,1686
 azure/durable_functions/models/actions/CallEntityAction.py,sha256=rYXiWqY5cNBqQH7I4wZYjcU1FBTRrOHV-o5Kg8Ct7PE,1672
 azure/durable_functions/models/actions/CallHttpAction.py,sha256=UaRTDzvO-W3MvSRj4zkxdSAWgU6qfm-0xjvPlrhPSGY,1162
-azure/durable_functions/models/actions/CallSubOrchestratorAction.py,sha256=-q73TW--QhyIijfaCldF0QKQ3Ar9FbSAJCy1HBu1-mY,1541
-azure/durable_functions/models/actions/CallSubOrchestratorWithRetryAction.py,sha256=S2TD8ulOZlQhi-xB6uzBhbvYEo435sUkIx3Abs6F0oo,1799
+azure/durable_functions/models/actions/CallSubOrchestratorAction.py,sha256=yYI7opZSSuf-h76TBOlF76wusJYf5UDbQPHZfxXUUnk,1678
+azure/durable_functions/models/actions/CallSubOrchestratorWithRetryAction.py,sha256=7HWaUpSkQWcWON7k8GG1Njvy4l3ZilR1jOZ2ex9bUsA,1936
 azure/durable_functions/models/actions/CompoundAction.py,sha256=qYySRtq5HuLLmOYMNFkrA0NuNlkT6RYuEeWQY7RIwvo,1117
 azure/durable_functions/models/actions/ContinueAsNewAction.py,sha256=Jrj28QRqxEXHjcs4yGF3tusjtKGH00MBbo6Z5dz6J4k,1195
 azure/durable_functions/models/actions/CreateTimerAction.py,sha256=pYVY4sH5iW7zecvueWljLBhVoLvXysmYdGE54URk90U,1575
@@ -51,7 +51,7 @@ azure/durable_functions/models/history/HistoryEventType.py,sha256=NdCQQrqvWFw5Gi
 azure/durable_functions/models/history/__init__.py,sha256=otJhZJN9OeGtWrW3lKbk2C1Nyf6I2wJfwuXpCZ2oxYM,237
 azure/durable_functions/models/utils/__init__.py,sha256=dQ6-HRUPsCtDIqGjRJ3TA6NXSYXzhw5yLA2OP-zkm-s,221
 azure/durable_functions/models/utils/entity_utils.py,sha256=TqNTtRC8VuKFtqWLq9oEAloioV-FyinjgRYVKkCldHo,2881
-azure/durable_functions/models/utils/http_utils.py,sha256=AoCWjCapd_984J_4296iJ8cNJWEG8GIdhRttBPt0HnA,2551
+azure/durable_functions/models/utils/http_utils.py,sha256=9-jLn-vLCCzxSkk_JyB4db0rk5Nqq7FHecavddPN1yA,6605
 azure/durable_functions/models/utils/json_utils.py,sha256=zUn62pm3dQw054ZlK7F4uRP-UELjQC8EmZBU1WncHMg,3811
 azure/durable_functions/openai_agents/__init__.py,sha256=pAUkXR5ctS0leHiR0IwBC1aHurzOn70wasL-LDRcRnQ,374
 azure/durable_functions/openai_agents/context.py,sha256=tShhQmlMxvOGHvYu55e10xPp2mVHmeIUf37yUzzjE50,7551
@@ -70,7 +70,7 @@ tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/models/test_DecoratorMetadata.py,sha256=0PeUDszF_gAJZMZR-K-Ro7c3I1D960amOLtbT88L_dk,3918
 tests/models/test_Decorators.py,sha256=y2dhoSlP74J5uAVBDY2JfFkSA-AhyagVBZO5tGi6KaQ,2925
 tests/models/test_DurableOrchestrationBindings.py,sha256=pjuoKlpEc6KAIL-Nq2taoqW0HYWXoupgUxcsPwc1Psg,2961
-tests/models/test_DurableOrchestrationClient.py,sha256=7htzuMMfkRU9Hf-9Gr-rYHpJXJdpnAp0WheAFpMKHNo,31791
+tests/models/test_DurableOrchestrationClient.py,sha256=JBi1l2ZPlZ9ksSpAvrlsKiLjyFwxWC-ol8Evp_dJmHU,35262
 tests/models/test_DurableOrchestrationContext.py,sha256=ewNEH2g8gn60bVftXT6zmI6nkANXB1u7XsC1l9vXFxg,4328
 tests/models/test_DurableOrchestrationStatus.py,sha256=fnUZxrHGy771OoaD5TInELhaG836aB8XqtMdNjnEFp8,2485
 tests/models/test_OrchestrationState.py,sha256=L-k8ScrqoDIZEqIUORbxXA7yCuMbVAUPr-7VmyuQkUc,1272
@@ -113,8 +113,9 @@ tests/test_utils/json_utils.py,sha256=B0q3COMya7TGxbH-7sD_0ypWDSuaF4fpD4QV_oJPgG
 tests/test_utils/testClasses.py,sha256=U_u5qKxC9U81SzjLo7ejjPjEn_cE5qjaqoq8edGD6l8,1521
 tests/utils/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 tests/utils/test_entity_utils.py,sha256=kdk5_DV_-bFu_5q2mw9o1yjyzh8Lcxv1jo1Q7is_ukA,748
-azure_functions_durable-1.4.0.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
-azure_functions_durable-1.4.0.dist-info/METADATA,sha256=UvSARgbXXpFbz_zAnWhFr10Zjm85VPBTkTgZTG7g2jw,3778
-azure_functions_durable-1.4.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-azure_functions_durable-1.4.0.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
-azure_functions_durable-1.4.0.dist-info/RECORD,,
+tests/utils/test_http_utils.py,sha256=-EJr4XX4611F-UVKTqLKMlKCDTMfZ7RWx7rXZj_xd-4,11171
+azure_functions_durable-1.5.0.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
+azure_functions_durable-1.5.0.dist-info/METADATA,sha256=cbh-wWD7zI8wf4MRxhzBDfKyNhtTIvN8BRhTBAkWIqY,3774
+azure_functions_durable-1.5.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
+azure_functions_durable-1.5.0.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
+azure_functions_durable-1.5.0.dist-info/RECORD,,

{azure_functions_durable-1.4.0.dist-info → azure_functions_durable-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: bdist_wheel (0.46.3)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/models/test_DurableOrchestrationClient.py

@@ -67,7 +67,8 @@ class MockRequest:
         assert url == self._expected_url
         return self._response
 
-    async def post(self, url: str, data: Any = None, trace_parent: str = None, trace_state: str = None):
+    async def post(self, url: str, data: Any = None, trace_parent: str = None,
+                   trace_state: str = None, function_invocation_id: str = None):
         assert url == self._expected_url
         return self._response
 
@@ -82,6 +83,17 @@ def test_get_start_new_url(binding_string):
     assert expected_url == start_new_url
 
 
+def test_get_start_new_url_with_version(binding_string):
+    client = DurableOrchestrationClient(binding_string)
+    instance_id = "2e2568e7-a906-43bd-8364-c81733c5891e"
+    function_name = "my_function"
+    version = "2.0"
+    start_new_url = client._get_start_new_url(instance_id, function_name, version)
+    expected_url = replace_stand_in_bits(
+        f"{RPC_BASE_URL}orchestrators/{function_name}/{instance_id}?version={version}")
+    assert expected_url == start_new_url
+
+
 def test_get_input_returns_none_when_none_supplied():
     result = DurableOrchestrationClient._get_json_input(None)
     assert result is None
@@ -728,3 +740,73 @@ async def test_post_500_resume(binding_string):
 
     with pytest.raises(Exception):
         await client.resume(TEST_INSTANCE_ID, raw_reason)
+
+
+# Tests for function_invocation_id parameter
+def test_client_stores_function_invocation_id(binding_string):
+    """Test that the client stores the function_invocation_id parameter."""
+    invocation_id = "test-invocation-123"
+    client = DurableOrchestrationClient(binding_string, function_invocation_id=invocation_id)
+    assert client._function_invocation_id == invocation_id
+
+
+def test_client_stores_none_when_no_invocation_id(binding_string):
+    """Test that the client stores None when no invocation ID is provided."""
+    client = DurableOrchestrationClient(binding_string)
+    assert client._function_invocation_id is None
+
+
+class MockRequestWithInvocationId:
+    """Mock request class that verifies function_invocation_id is passed."""
+
+    def __init__(self, expected_url: str, response: [int, any], expected_invocation_id: str = None):
+        self._expected_url = expected_url
+        self._response = response
+        self._expected_invocation_id = expected_invocation_id
+        self._received_invocation_id = None
+
+    @property
+    def received_invocation_id(self):
+        return self._received_invocation_id
+
+    async def post(self, url: str, data: Any = None, trace_parent: str = None,
+                   trace_state: str = None, function_invocation_id: str = None):
+        assert url == self._expected_url
+        self._received_invocation_id = function_invocation_id
+        if self._expected_invocation_id is not None:
+            assert function_invocation_id == self._expected_invocation_id
+        return self._response
+
+
+@pytest.mark.asyncio
+async def test_start_new_passes_invocation_id(binding_string):
+    """Test that start_new passes the function_invocation_id to the HTTP request."""
+    invocation_id = "test-invocation-456"
+    function_name = "MyOrchestrator"
+
+    mock_request = MockRequestWithInvocationId(
+        expected_url=f"{RPC_BASE_URL}orchestrators/{function_name}",
+        response=[202, {"id": TEST_INSTANCE_ID}],
+        expected_invocation_id=invocation_id)
+
+    client = DurableOrchestrationClient(binding_string, function_invocation_id=invocation_id)
+    client._post_async_request = mock_request.post
+
+    await client.start_new(function_name)
+    assert mock_request.received_invocation_id == invocation_id
+
+
+@pytest.mark.asyncio
+async def test_start_new_passes_none_when_no_invocation_id(binding_string):
+    """Test that start_new passes None when no invocation ID is provided."""
+    function_name = "MyOrchestrator"
+
+    mock_request = MockRequestWithInvocationId(
+        expected_url=f"{RPC_BASE_URL}orchestrators/{function_name}",
+        response=[202, {"id": TEST_INSTANCE_ID}])
+
+    client = DurableOrchestrationClient(binding_string)
+    client._post_async_request = mock_request.post
+
+    await client.start_new(function_name)
+    assert mock_request.received_invocation_id is None

tests/utils/test_http_utils.py

@@ -0,0 +1,287 @@
+"""Tests for http_utils module to verify ClientSession reuse."""
+import pytest
+from unittest.mock import AsyncMock, patch, Mock
+from azure.durable_functions.models.utils import http_utils
+
+
+@pytest.mark.asyncio
+async def test_session_is_reused_across_requests():
+    """Test that the same session is reused for multiple requests."""
+    # Reset the session to start fresh
+    http_utils._client_session = None
+
+    # Make first request to create session
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        # Create a proper async context manager
+        mock_post_context = AsyncMock()
+        mock_post_context.__aenter__.return_value = mock_response
+        mock_post_context.__aexit__.return_value = None
+        mock_session.post.return_value = mock_post_context
+        mock_session.closed = False
+        mock_session_class.return_value = mock_session
+
+        # First request
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test1"})
+
+        # Verify session was created once
+        assert mock_session_class.call_count == 1
+        first_session = http_utils._client_session
+
+        # Second request - should reuse same session
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test2"})
+
+        # Verify session was NOT created again
+        assert mock_session_class.call_count == 1
+        assert http_utils._client_session is first_session
+
+
+@pytest.mark.asyncio
+async def test_session_recreated_after_close():
+    """Test that a new session is created if the previous one was closed."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session1 = Mock()
+        mock_session1.closed = False
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        mock_post_context = AsyncMock()
+        mock_post_context.__aenter__.return_value = mock_response
+        mock_post_context.__aexit__.return_value = None
+        mock_session1.post.return_value = mock_post_context
+
+        mock_session2 = Mock()
+        mock_session2.closed = False
+        mock_session2.post.return_value = mock_post_context
+
+        mock_session_class.side_effect = [mock_session1, mock_session2]
+
+        # First request creates session
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test1"})
+        assert mock_session_class.call_count == 1
+
+        # Simulate session being closed
+        mock_session1.closed = True
+
+        # Second request should create new session
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test2"})
+        assert mock_session_class.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_session_closed_on_connection_error():
+    """Test that session is closed and reset on connection errors."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_session.close = AsyncMock()
+
+        # First request succeeds
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        mock_post_context_success = AsyncMock()
+        mock_post_context_success.__aenter__.return_value = mock_response
+        mock_post_context_success.__aexit__.return_value = None
+
+        mock_session.post.return_value = mock_post_context_success
+        mock_session_class.return_value = mock_session
+
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test1"})
+        assert http_utils._client_session is not None
+
+        # Second request raises connection error
+        from aiohttp import ClientError
+        mock_post_context_error = AsyncMock()
+        mock_post_context_error.__aenter__.side_effect = \
+            ClientError("Connection failed")
+        mock_session.post.return_value = mock_post_context_error
+
+        with pytest.raises(ClientError):
+            await http_utils.post_async_request("http://test.com",
+                                                {"data": "test2"})
+
+        # Verify close was called
+        mock_session.close.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_request_uses_shared_session():
+    """Test that GET requests use the shared session."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "data"})
+
+        mock_get_context = AsyncMock()
+        mock_get_context.__aenter__.return_value = mock_response
+        mock_get_context.__aexit__.return_value = None
+        mock_session.get.return_value = mock_get_context
+        mock_session_class.return_value = mock_session
+
+        # Make GET request
+        await http_utils.get_async_request("http://test.com")
+
+        # Make another GET request
+        await http_utils.get_async_request("http://test.com")
+
+        # Verify session was created only once
+        assert mock_session_class.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_delete_request_uses_shared_session():
+    """Test that DELETE requests use the shared session."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "deleted"})
+
+        mock_delete_context = AsyncMock()
+        mock_delete_context.__aenter__.return_value = mock_response
+        mock_delete_context.__aexit__.return_value = None
+        mock_session.delete.return_value = mock_delete_context
+        mock_session_class.return_value = mock_session
+
+        # Make DELETE request
+        await http_utils.delete_async_request("http://test.com")
+
+        # Make another DELETE request
+        await http_utils.delete_async_request("http://test.com")
+
+        # Verify session was created only once
+        assert mock_session_class.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_session_configured_with_timeouts():
+    """Test that session is configured with appropriate timeouts."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class, \
+            patch('aiohttp.ClientTimeout') as mock_timeout_class, \
+            patch('aiohttp.TCPConnector') as mock_connector_class:
+
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        mock_post_context = AsyncMock()
+        mock_post_context.__aenter__.return_value = mock_response
+        mock_post_context.__aexit__.return_value = None
+        mock_session.post.return_value = mock_post_context
+        mock_session_class.return_value = mock_session
+
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test"})
+
+        # Verify timeout was configured for localhost IPC
+        mock_timeout_class.assert_called_once()
+        timeout_call = mock_timeout_class.call_args
+        assert timeout_call.kwargs['total'] == 240
+        assert timeout_call.kwargs['sock_connect'] == 10
+        assert timeout_call.kwargs['sock_read'] is None
+
+        # Verify connector was configured for localhost IPC
+        mock_connector_class.assert_called_once()
+        connector_call = mock_connector_class.call_args
+        assert connector_call.kwargs['limit'] == 30
+        assert connector_call.kwargs['limit_per_host'] == 30
+
+
+@pytest.mark.asyncio
+async def test_close_session():
+    """Test the _close_session function."""
+    # Reset and create a session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_session.close = AsyncMock()
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        mock_post_context = AsyncMock()
+        mock_post_context.__aenter__.return_value = mock_response
+        mock_post_context.__aexit__.return_value = None
+        mock_session.post.return_value = mock_post_context
+        mock_session_class.return_value = mock_session
+
+        # Create session
+        await http_utils.post_async_request("http://test.com",
+                                            {"data": "test"})
+        assert http_utils._client_session is not None
+
+        # Close session
+        await http_utils._close_session()
+
+        # Verify close was called and session is None
+        mock_session.close.assert_called_once()
+        assert http_utils._client_session is None
+
+
+@pytest.mark.asyncio
+async def test_trace_headers_are_passed():
+    """Test that trace headers are properly passed in requests."""
+    # Reset the session
+    http_utils._client_session = None
+
+    with patch('aiohttp.ClientSession') as mock_session_class:
+        mock_session = Mock()
+        mock_session.closed = False
+        mock_response = AsyncMock()
+        mock_response.status = 200
+        mock_response.json = AsyncMock(return_value={"result": "success"})
+
+        mock_post_context = AsyncMock()
+        mock_post_context.__aenter__.return_value = mock_response
+        mock_post_context.__aexit__.return_value = None
+        mock_session.post.return_value = mock_post_context
+        mock_session_class.return_value = mock_session
+
+        trace_parent = "00-trace-id-parent"
+        trace_state = "state=value"
+
+        await http_utils.post_async_request(
+            "http://test.com",
+            {"data": "test"},
+            trace_parent=trace_parent,
+            trace_state=trace_state
+        )
+
+        # Verify headers were passed
+        call_args = mock_session.post.call_args
+        assert call_args.kwargs['headers']['traceparent'] == trace_parent
+        assert call_args.kwargs['headers']['tracestate'] == trace_state