Python: Allow custom httpx client timeout when not using custom client (#12379)

### Motivation and Context

Currently, if one is using the OpenAPI plugin within SK, and not
providing a custom httpx client, they are hit with a hard-coded 5 second
timeout. Devs need a way to be able to customize the timeout.

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->

### Description

Provide a way to customize the timeout used during API calls.
- Closes #12373 
- Adds unit tests

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [X] The code builds clean without any errors or warnings
- [X] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [X] All unit tests pass, and I have added new tests where possible
- [X] I didn't break anyone 😄

Author: moonbox3

python/semantic_kernel/connectors/openapi_plugin/models/rest_api_run_options.py

@@ -1,13 +1,19 @@
 # Copyright (c) Microsoft. All rights reserved.
 
-from semantic_kernel.utils.feature_stage_decorator import experimental
 
-
-@experimental
 class RestApiRunOptions:
     """The options for running the REST API operation."""
 
-    def __init__(self, server_url_override=None, api_host_url=None) -> None:
-        """Initialize the REST API operation run options."""
-        self.server_url_override: str = server_url_override
-        self.api_host_url: str = api_host_url
+    def __init__(
+        self, server_url_override: str | None = None, api_host_url: str | None = None, timeout: float | None = None
+    ) -> None:
+        """Initialize the REST API operation run options.
+
+        Args:
+            server_url_override: The server URL override, if any.
+            api_host_url: The API host URL, if any.
+            timeout: The timeout for the operation, if any.
+        """
+        self.server_url_override: str | None = server_url_override
+        self.api_host_url: str | None = api_host_url
+        self.timeout: float | None = timeout

python/semantic_kernel/connectors/openapi_plugin/openapi_function_execution_parameters.py

@@ -11,12 +11,10 @@
     OperationSelectionPredicateContext,
 )
 from semantic_kernel.kernel_pydantic import KernelBaseModel
-from semantic_kernel.utils.feature_stage_decorator import experimental
 
 AuthCallbackType = Callable[..., Awaitable[Any]]
 
 
-@experimental
 class OpenAPIFunctionExecutionParameters(KernelBaseModel):
     """OpenAPI function execution parameters."""
 
@@ -29,6 +27,9 @@ class OpenAPIFunctionExecutionParameters(KernelBaseModel):
     enable_payload_namespacing: bool = False
     operations_to_exclude: list[str] = Field(default_factory=list, description="The operationId(s) to exclude")
     operation_selection_predicate: Callable[[OperationSelectionPredicateContext], bool] | None = None
+    timeout: float | None = Field(
+        None, description="Default timeout in seconds for HTTP requests. Uses httpx default (5 seconds) if None."
+    )
 
     def model_post_init(self, __context: Any) -> None:
         """Post initialization method for the model."""

python/semantic_kernel/connectors/openapi_plugin/openapi_manager.py

@@ -2,7 +2,6 @@
 
 import logging
 from typing import TYPE_CHECKING, Any
-from urllib.parse import urlparse
 
 from semantic_kernel.connectors.openapi_plugin.const import OperationExtensions
 from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation import RestApiOperation
@@ -146,9 +145,14 @@ async def run_openapi_operation(
 
             options = RestApiRunOptions(
                 server_url_override=(
-                    urlparse(execution_parameters.server_url_override) if execution_parameters else None
+                    execution_parameters.server_url_override
+                    if execution_parameters and execution_parameters.server_url_override is not None
+                    else None
                 ),
                 api_host_url=Uri(document_uri).get_left_part() if document_uri is not None else None,
+                timeout=execution_parameters.timeout
+                if execution_parameters and execution_parameters.timeout is not None
+                else None,
             )
 
             return await runner.run_operation(operation, kernel_arguments, options)

python/semantic_kernel/connectors/openapi_plugin/openapi_runner.py

@@ -159,6 +159,8 @@ async def run_operation(
             )
             headers["Content-Type"] = self._get_first_response_media_type(responses)
 
+        timeout = options.timeout if options and hasattr(options, "timeout") and options.timeout is not None else None
+
         async def fetch():
             async def make_request(client: httpx.AsyncClient):
                 merged_headers = client.headers.copy()
@@ -174,7 +176,7 @@ async def make_request(client: httpx.AsyncClient):
 
             if hasattr(self, "http_client") and self.http_client is not None:
                 return await make_request(self.http_client)
-            async with httpx.AsyncClient(timeout=5) as client:
+            async with httpx.AsyncClient(timeout=timeout) as client:
                 return await make_request(client)
 
         return await fetch()

python/tests/unit/connectors/openapi_plugin/test_openapi_manager.py

@@ -8,10 +8,12 @@
     RestApiParameter,
     RestApiParameterLocation,
 )
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_run_options import RestApiRunOptions
 from semantic_kernel.connectors.openapi_plugin.openapi_manager import (
     _create_function_from_operation,
     create_functions_from_openapi,
 )
+from semantic_kernel.connectors.openapi_plugin.openapi_runner import OpenApiRunner
 from semantic_kernel.exceptions import FunctionExecutionException
 from semantic_kernel.functions.kernel_function_decorator import kernel_function
 from semantic_kernel.functions.kernel_parameter_metadata import KernelParameterMetadata
@@ -222,3 +224,49 @@ async def test_create_functions_from_openapi_raises_exception(mock_parse):
         create_functions_from_openapi(plugin_name="test_plugin", openapi_document_path="test_openapi_document_path")
 
     mock_parse.assert_called_once_with("test_openapi_document_path")
+
+
+async def test_run_operation_uses_timeout_from_run_options():
+    minimal_openapi_spec = {
+        "openapi": "3.0.0",
+        "info": {"title": "Test", "version": "1.0.0"},
+        "paths": {},
+    }
+    runner = OpenApiRunner(parsed_openapi_document=minimal_openapi_spec)
+    operation = MagicMock()
+    operation.method = "GET"
+    operation.build_headers.return_value = {}
+    operation.build_operation_payload.return_value = ("{}", None)
+    operation.responses = {}
+    operation.responses = {}
+    operation.operation_id = "test_id"
+
+    desired_timeout = 3.3
+
+    with (
+        patch("httpx.AsyncClient.__aenter__", new_callable=AsyncMock) as mock_enter,
+        patch("httpx.AsyncClient.__aexit__", new_callable=AsyncMock),
+        patch("httpx.AsyncClient.__init__", return_value=None) as mock_init,
+    ):
+        mock_client = MagicMock()
+        mock_enter.return_value = mock_client
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.text = "FAKE_RESPONSE"
+        mock_client.request = AsyncMock(return_value=mock_response)
+
+        operation.build_query_string.return_value = ""
+        operation.server_url = "https://api.example.com"
+        operation.path = "/test"
+        operation.build_operation_url.return_value = "https://api.example.com/test"
+        result = await runner.run_operation(
+            operation=operation, arguments=None, options=RestApiRunOptions(timeout=desired_timeout)
+        )
+
+        assert result == "FAKE_RESPONSE"
+        found = False
+        for call_args in mock_init.call_args_list:
+            if "timeout" in call_args.kwargs and call_args.kwargs["timeout"] == desired_timeout:
+                found = True
+                break
+        assert found, f"httpx.AsyncClient was not called with timeout={desired_timeout}"

python/tests/unit/connectors/openapi_plugin/test_rest_api_operation_run_options.py

@@ -6,11 +6,13 @@
 def test_initialization():
     server_url_override = "http://example.com"
     api_host_url = "http://example.com"
+    timeout = 30.0
 
-    rest_api_operation_run_options = RestApiRunOptions(server_url_override, api_host_url)
+    rest_api_operation_run_options = RestApiRunOptions(server_url_override, api_host_url, timeout)
 
     assert rest_api_operation_run_options.server_url_override == server_url_override
     assert rest_api_operation_run_options.api_host_url == api_host_url
+    assert rest_api_operation_run_options.timeout == timeout
 
 
 def test_initialization_no_params():