semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/openapi_plugin/openapi_manager.py

@@ -0,0 +1,156 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
+
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation import RestApiOperation
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_parameter import RestApiOperationParameter
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_run_options import RestApiOperationRunOptions
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_uri import Uri
+from semantic_kernel.connectors.openapi_plugin.openapi_parser import OpenApiParser
+from semantic_kernel.connectors.openapi_plugin.openapi_runner import OpenApiRunner
+from semantic_kernel.exceptions.function_exceptions import FunctionExecutionException
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.functions.kernel_function_decorator import kernel_function
+from semantic_kernel.functions.kernel_function_from_method import KernelFunctionFromMethod
+from semantic_kernel.functions.kernel_parameter_metadata import KernelParameterMetadata
+from semantic_kernel.schema.kernel_json_schema_builder import TYPE_MAPPING
+from semantic_kernel.utils.experimental_decorator import experimental_function
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.openai_plugin.openai_function_execution_parameters import (
+        OpenAIFunctionExecutionParameters,
+    )
+    from semantic_kernel.connectors.openapi_plugin.openapi_function_execution_parameters import (
+        OpenAPIFunctionExecutionParameters,
+    )
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_function
+def create_functions_from_openapi(
+    plugin_name: str,
+    openapi_document_path: str,
+    execution_settings: "OpenAIFunctionExecutionParameters | OpenAPIFunctionExecutionParameters | None" = None,
+) -> list[KernelFunctionFromMethod]:
+    """Creates the functions from OpenAPI document.
+
+    Args:
+        plugin_name: The name of the plugin
+        openapi_document_path: The OpenAPI document path, it must be a file path to the spec.
+        execution_settings: The execution settings
+
+    Returns:
+        list[KernelFunctionFromMethod]: the operations as functions
+    """
+    parser = OpenApiParser()
+    if (parsed_doc := parser.parse(openapi_document_path)) is None:
+        raise FunctionExecutionException(f"Error parsing OpenAPI document: {openapi_document_path}")
+    operations = parser.create_rest_api_operations(parsed_doc, execution_settings=execution_settings)
+
+    auth_callback = None
+    if execution_settings and execution_settings.auth_callback:
+        auth_callback = execution_settings.auth_callback
+
+    openapi_runner = OpenApiRunner(
+        parsed_openapi_document=parsed_doc,
+        auth_callback=auth_callback,
+        http_client=execution_settings.http_client if execution_settings else None,
+        enable_dynamic_payload=execution_settings.enable_dynamic_payload if execution_settings else True,
+        enable_payload_namespacing=execution_settings.enable_payload_namespacing if execution_settings else False,
+    )
+
+    return [
+        _create_function_from_operation(openapi_runner, operation, plugin_name, execution_parameters=execution_settings)
+        for operation in operations.values()
+    ]
+
+
+@experimental_function
+def _create_function_from_operation(
+    runner: OpenApiRunner,
+    operation: RestApiOperation,
+    plugin_name: str | None = None,
+    execution_parameters: "OpenAIFunctionExecutionParameters | OpenAPIFunctionExecutionParameters | None" = None,
+    document_uri: str | None = None,
+) -> KernelFunctionFromMethod:
+    logger.info(f"Registering OpenAPI operation: {plugin_name}.{operation.id}")
+
+    rest_operation_params: list[RestApiOperationParameter] = operation.get_parameters(
+        operation=operation,
+        add_payload_params_from_metadata=getattr(execution_parameters, "enable_dynamic_payload", True),
+        enable_payload_spacing=getattr(execution_parameters, "enable_payload_namespacing", False),
+    )
+
+    @kernel_function(
+        description=operation.summary if operation.summary else operation.description,
+        name=operation.id,
+    )
+    async def run_openapi_operation(
+        **kwargs: dict[str, Any],
+    ) -> str:
+        try:
+            kernel_arguments = KernelArguments()
+
+            for parameter in rest_operation_params:
+                if parameter.alternative_name and parameter.alternative_name in kwargs:
+                    value = kwargs[parameter.alternative_name]
+                    if value is not None:
+                        kernel_arguments[parameter.name] = value
+                        continue
+
+                if parameter.name in kwargs:
+                    value = kwargs[parameter.name]
+                    if value is not None:
+                        kernel_arguments[parameter.name] = value
+                        continue
+
+                if parameter.is_required:
+                    raise FunctionExecutionException(
+                        f"No variable found in context to use as an argument for the "
+                        f"`{parameter.name}` parameter of the `{plugin_name}.{operation.id}` REST function."
+                    )
+
+            options = RestApiOperationRunOptions(
+                server_url_override=(
+                    urlparse(execution_parameters.server_url_override) if execution_parameters else None
+                ),
+                api_host_url=Uri(document_uri).get_left_part() if document_uri is not None else None,
+            )
+
+            return await runner.run_operation(operation, kernel_arguments, options)
+        except Exception as e:
+            logger.error(f"Error running OpenAPI operation: {operation.id}", exc_info=True)
+            raise FunctionExecutionException(f"Error running OpenAPI operation: {operation.id}") from e
+
+    parameters: list[KernelParameterMetadata] = [
+        KernelParameterMetadata(
+            name=p.alternative_name or p.name,
+            description=f"{p.description or p.name}",
+            default_value=p.default_value or "",
+            is_required=p.is_required,
+            type_=p.type if p.type is not None else TYPE_MAPPING.get(p.type, "object"),
+            schema_data=(
+                p.schema
+                if p.schema is not None and isinstance(p.schema, dict)
+                else {"type": f"{p.type}"}
+                if p.type
+                else None
+            ),
+        )
+        for p in rest_operation_params
+    ]
+
+    return_parameter = operation.get_default_return_parameter()
+
+    additional_metadata = {"method": operation.method.upper()}
+
+    return KernelFunctionFromMethod(
+        method=run_openapi_operation,
+        plugin_name=plugin_name,
+        parameters=parameters,
+        return_parameter=return_parameter,
+        additional_metadata=additional_metadata,
+    )

semantic_kernel-1.8.3/semantic_kernel/connectors/openapi_plugin/openapi_parser.py

@@ -0,0 +1,213 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections import OrderedDict
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any, Final
+from urllib.parse import urlparse
+
+from prance import ResolvingParser
+
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation import RestApiOperation
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_expected_response import (
+    RestApiOperationExpectedResponse,
+)
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_parameter import RestApiOperationParameter
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_parameter_location import (
+    RestApiOperationParameterLocation,
+)
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_payload import RestApiOperationPayload
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_payload_property import (
+    RestApiOperationPayloadProperty,
+)
+from semantic_kernel.exceptions.function_exceptions import PluginInitializationError
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.openai_plugin.openai_function_execution_parameters import (
+        OpenAIFunctionExecutionParameters,
+    )
+    from semantic_kernel.connectors.openapi_plugin.openapi_function_execution_parameters import (
+        OpenAPIFunctionExecutionParameters,
+    )
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_class
+class OpenApiParser:
+    """NOTE: SK Python only supports the OpenAPI Spec >=3.0.
+
+    Import an OpenAPI file.
+
+    Args:
+        openapi_file: The path to the OpenAPI file which can be local or a URL.
+
+    Returns:
+        The parsed OpenAPI file
+
+
+    :param openapi_file: The path to the OpenAPI file which can be local or a URL.
+    :return: The parsed OpenAPI file
+    """
+
+    PAYLOAD_PROPERTIES_HIERARCHY_MAX_DEPTH: int = 10
+    SUPPORTED_MEDIA_TYPES: Final[list[str]] = ["application/json", "text/plain"]
+
+    def parse(self, openapi_document: str) -> Any | dict[str, Any] | None:
+        """Parse the OpenAPI document."""
+        parser = ResolvingParser(openapi_document)
+        return parser.specification
+
+    def _parse_parameters(self, parameters: list[dict[str, Any]]):
+        """Parse the parameters from the OpenAPI document."""
+        result: list[RestApiOperationParameter] = []
+        for param in parameters:
+            name = param["name"]
+            type = param["schema"]["type"]
+            if not param.get("in"):
+                raise PluginInitializationError(f"Parameter {name} is missing 'in' field")
+            location = RestApiOperationParameterLocation(param["in"])
+            description = param.get("description", None)
+            is_required = param.get("required", False)
+            default_value = param.get("default", None)
+            schema = param.get("schema", None)
+            schema_type = schema.get("type", None) if schema else "string"
+
+            result.append(
+                RestApiOperationParameter(
+                    name=name,
+                    type=type,
+                    location=location,
+                    description=description,
+                    is_required=is_required,
+                    default_value=default_value,
+                    schema=schema_type,
+                )
+            )
+        return result
+
+    def _get_payload_properties(self, operation_id, schema, required_properties, level=0):
+        if schema is None:
+            return []
+
+        if level > OpenApiParser.PAYLOAD_PROPERTIES_HIERARCHY_MAX_DEPTH:
+            raise Exception(
+                f"Max level {OpenApiParser.PAYLOAD_PROPERTIES_HIERARCHY_MAX_DEPTH} of "
+                f"traversing payload properties of `{operation_id}` operation is exceeded."
+            )
+
+        result = []
+
+        for property_name, property_schema in schema.get("properties", {}).items():
+            default_value = property_schema.get("default", None)
+
+            property = RestApiOperationPayloadProperty(
+                name=property_name,
+                type=property_schema.get("type", None),
+                is_required=property_name in required_properties,
+                properties=self._get_payload_properties(operation_id, property_schema, required_properties, level + 1),
+                description=property_schema.get("description", None),
+                schema=property_schema,
+                default_value=default_value,
+            )
+
+            result.append(property)
+
+        return result
+
+    def _create_rest_api_operation_payload(
+        self, operation_id: str, request_body: dict[str, Any]
+    ) -> RestApiOperationPayload | None:
+        if request_body is None or request_body.get("content") is None:
+            return None
+
+        content = request_body.get("content")
+        if content is None:
+            return None
+
+        media_type = next((mt for mt in OpenApiParser.SUPPORTED_MEDIA_TYPES if mt in content), None)
+        if media_type is None:
+            raise Exception(f"Neither of the media types of {operation_id} is supported.")
+
+        media_type_metadata = content[media_type]
+        payload_properties = self._get_payload_properties(
+            operation_id, media_type_metadata["schema"], media_type_metadata["schema"].get("required", set())
+        )
+        return RestApiOperationPayload(
+            media_type,
+            payload_properties,
+            request_body.get("description"),
+            schema=media_type_metadata.get("schema", None),
+        )
+
+    def _create_response(
+        self, responses: dict[str, Any]
+    ) -> Generator[tuple[str, RestApiOperationExpectedResponse], None, None]:
+        for response_key, response_value in responses.items():
+            media_type = next(
+                (mt for mt in OpenApiParser.SUPPORTED_MEDIA_TYPES if mt in response_value.get("content", {})), None
+            )
+            if media_type is not None:
+                matching_schema = response_value["content"][media_type].get("schema", {})
+                description = response_value.get("description") or matching_schema.get("description", "")
+                yield (
+                    response_key,
+                    RestApiOperationExpectedResponse(
+                        description=description,
+                        media_type=media_type,
+                        schema=matching_schema if matching_schema else None,
+                    ),
+                )
+
+    def create_rest_api_operations(
+        self,
+        parsed_document: Any,
+        execution_settings: "OpenAIFunctionExecutionParameters | OpenAPIFunctionExecutionParameters | None" = None,
+    ) -> dict[str, RestApiOperation]:
+        """Create the REST API Operations from the parsed OpenAPI document.
+
+        Args:
+            parsed_document: The parsed OpenAPI document
+            execution_settings: The execution settings
+
+        Returns:
+            A dictionary of RestApiOperation objects keyed by operationId
+        """
+        paths = parsed_document.get("paths", {})
+        request_objects = {}
+
+        base_url = "/"
+        servers = parsed_document.get("servers", [])
+        base_url = servers[0].get("url") if servers else "/"
+
+        if execution_settings and execution_settings.server_url_override:
+            base_url = execution_settings.server_url_override
+
+        for path, methods in paths.items():
+            for method, details in methods.items():
+                request_method = method.lower()
+
+                parameters = details.get("parameters", [])
+                operationId = details.get("operationId", path + "_" + request_method)
+                summary = details.get("summary", None)
+                description = details.get("description", None)
+
+                parsed_params = self._parse_parameters(parameters)
+                request_body = self._create_rest_api_operation_payload(operationId, details.get("requestBody", None))
+                responses = dict(self._create_response(details.get("responses", {})))
+
+                rest_api_operation = RestApiOperation(
+                    id=operationId,
+                    method=request_method,
+                    server_url=urlparse(base_url),
+                    path=path,
+                    params=parsed_params,
+                    request_body=request_body,
+                    summary=summary,
+                    description=description,
+                    responses=OrderedDict(responses),
+                )
+
+                request_objects[operationId] = rest_api_operation
+        return request_objects

semantic_kernel-1.8.3/semantic_kernel/connectors/openapi_plugin/openapi_runner.py

@@ -0,0 +1,184 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import json
+import logging
+from collections import OrderedDict
+from collections.abc import Awaitable, Callable, Mapping
+from inspect import isawaitable
+from typing import Any
+from urllib.parse import urlparse, urlunparse
+
+import httpx
+from openapi_core import Spec
+
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation import RestApiOperation
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_expected_response import (
+    RestApiOperationExpectedResponse,
+)
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_payload import RestApiOperationPayload
+from semantic_kernel.connectors.openapi_plugin.models.rest_api_operation_run_options import RestApiOperationRunOptions
+from semantic_kernel.exceptions.function_exceptions import FunctionExecutionException
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.utils.experimental_decorator import experimental_class
+from semantic_kernel.utils.telemetry.user_agent import APP_INFO, prepend_semantic_kernel_to_user_agent
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_class
+class OpenApiRunner:
+    """The OpenApiRunner that runs the operations defined in the OpenAPI manifest."""
+
+    payload_argument_name = "payload"
+    media_type_application_json = "application/json"
+
+    def __init__(
+        self,
+        parsed_openapi_document: Mapping[str, str],
+        auth_callback: Callable[..., dict[str, str] | Awaitable[dict[str, str]]] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        enable_dynamic_payload: bool = True,
+        enable_payload_namespacing: bool = False,
+    ):
+        """Initialize the OpenApiRunner."""
+        self.spec = Spec.from_dict(parsed_openapi_document)  # type: ignore
+        self.auth_callback = auth_callback
+        self.http_client = http_client
+        self.enable_dynamic_payload = enable_dynamic_payload
+        self.enable_payload_namespacing = enable_payload_namespacing
+
+    def build_full_url(self, base_url, query_string):
+        """Build the full URL."""
+        url_parts = list(urlparse(base_url))
+        url_parts[4] = query_string
+        return urlunparse(url_parts)
+
+    def build_operation_url(
+        self, operation: RestApiOperation, arguments: KernelArguments, server_url_override=None, api_host_url=None
+    ):
+        """Build the operation URL."""
+        url = operation.build_operation_url(arguments, server_url_override, api_host_url)
+        return self.build_full_url(url, operation.build_query_string(arguments))
+
+    def build_json_payload(
+        self, payload_metadata: RestApiOperationPayload, arguments: dict[str, Any]
+    ) -> tuple[str, str]:
+        """Build the JSON payload."""
+        if self.enable_dynamic_payload:
+            if payload_metadata is None:
+                raise FunctionExecutionException(
+                    "Payload can't be built dynamically due to the missing payload metadata."
+                )
+
+            payload = self.build_json_object(payload_metadata.properties, arguments)
+            content = json.dumps(payload)
+            return content, payload_metadata.media_type
+
+        argument = arguments.get(self.payload_argument_name)
+        if not isinstance(argument, str):
+            raise FunctionExecutionException(f"No payload is provided by the argument '{self.payload_argument_name}'.")
+
+        return argument, argument
+
+    def build_json_object(self, properties, arguments, property_namespace=None):
+        """Build the JSON payload object."""
+        result = {}
+
+        for property_metadata in properties:
+            argument_name = self.get_argument_name_for_payload(property_metadata.name, property_namespace)
+            if property_metadata.type == "object":
+                node = self.build_json_object(property_metadata.properties, arguments, argument_name)
+                result[property_metadata.name] = node
+                continue
+            property_value = arguments.get(argument_name)
+            if property_value is not None:
+                result[property_metadata.name] = property_value
+                continue
+            if property_metadata.is_required:
+                raise FunctionExecutionException(
+                    f"No argument is found for the '{property_metadata.name}' payload property."
+                )
+        return result
+
+    def build_operation_payload(
+        self, operation: RestApiOperation, arguments: KernelArguments
+    ) -> tuple[str, str] | tuple[None, None]:
+        """Build the operation payload."""
+        if operation.request_body is None and self.payload_argument_name not in arguments:
+            return None, None
+
+        if operation.request_body is not None:
+            return self.build_json_payload(operation.request_body, arguments)
+
+        return None, None
+
+    def get_argument_name_for_payload(self, property_name, property_namespace=None):
+        """Get argument name for the payload."""
+        if not self.enable_payload_namespacing:
+            return property_name
+        return f"{property_namespace}.{property_name}" if property_namespace else property_name
+
+    def _get_first_response_media_type(
+        self, responses: OrderedDict[str, RestApiOperationExpectedResponse] | None
+    ) -> str:
+        if responses:
+            first_response = next(iter(responses.values()))
+            return first_response.media_type if first_response.media_type else self.media_type_application_json
+        return self.media_type_application_json
+
+    async def run_operation(
+        self,
+        operation: RestApiOperation,
+        arguments: KernelArguments | None = None,
+        options: RestApiOperationRunOptions | None = None,
+    ) -> str:
+        """Runs the operation defined in the OpenAPI manifest."""
+        if not arguments:
+            arguments = KernelArguments()
+        url = self.build_operation_url(
+            operation=operation,
+            arguments=arguments,
+            server_url_override=options.server_url_override if options else None,
+            api_host_url=options.api_host_url if options else None,
+        )
+        headers = operation.build_headers(arguments=arguments)
+        payload, _ = self.build_operation_payload(operation=operation, arguments=arguments)
+
+        if self.auth_callback:
+            headers_update = self.auth_callback(**headers)
+            if isawaitable(headers_update):
+                headers_update = await headers_update
+            # at this point, headers_update is a valid dictionary
+            headers.update(headers_update)  # type: ignore
+
+        if APP_INFO:
+            headers.update(APP_INFO)
+            headers = prepend_semantic_kernel_to_user_agent(headers)
+
+        if "Content-Type" not in headers:
+            responses = (
+                operation.responses
+                if isinstance(operation.responses, OrderedDict)
+                else OrderedDict(operation.responses or {})
+            )
+            headers["Content-Type"] = self._get_first_response_media_type(responses)
+
+        async def fetch():
+            async def make_request(client: httpx.AsyncClient):
+                merged_headers = client.headers.copy()
+                merged_headers.update(headers)
+                response = await client.request(
+                    method=operation.method,
+                    url=url,
+                    headers=merged_headers,
+                    json=json.loads(payload) if payload else None,
+                )
+                response.raise_for_status()
+                return response.text
+
+            if hasattr(self, "http_client") and self.http_client is not None:
+                return await make_request(self.http_client)
+            async with httpx.AsyncClient() as client:
+                return await make_request(client)
+
+        return await fetch()

semantic_kernel-1.8.3/semantic_kernel/connectors/search_engine/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.search_engine.bing_connector import BingConnector
+from semantic_kernel.connectors.search_engine.google_connector import GoogleConnector
+
+__all__ = ["BingConnector", "GoogleConnector"]

semantic_kernel-1.8.3/semantic_kernel/connectors/search_engine/bing_connector.py

@@ -0,0 +1,98 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import urllib
+
+from httpx import AsyncClient, HTTPStatusError, RequestError
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.search_engine.bing_connector_settings import BingSettings
+from semantic_kernel.connectors.search_engine.connector import ConnectorBase
+from semantic_kernel.exceptions import ServiceInitializationError, ServiceInvalidRequestError
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class BingConnector(ConnectorBase):
+    """A search engine connector that uses the Bing Search API to perform a web search."""
+
+    _settings: BingSettings
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        custom_config: str | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initializes a new instance of the BingConnector class.
+
+        Args:
+            api_key (str | None): The Bing Search API key. If provided, will override
+                the value in the env vars or .env file.
+            custom_config (str | None): The Bing Custom Search instance's unique identifier.
+                If provided, will override the value in the env vars or .env file.
+            env_file_path (str | None): The optional path to the .env file. If provided,
+                the settings are read from this file path location.
+            env_file_encoding (str | None): The optional encoding of the .env file.
+        """
+        try:
+            self._settings = BingSettings.create(
+                api_key=api_key,
+                custom_config=custom_config,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create Bing settings.") from ex
+
+    async def search(self, query: str, num_results: int = 1, offset: int = 0) -> list[str]:
+        """Returns the search results of the query provided by pinging the Bing web search API."""
+        if not query:
+            raise ServiceInvalidRequestError("query cannot be 'None' or empty.")
+
+        if num_results <= 0:
+            raise ServiceInvalidRequestError("num_results value must be greater than 0.")
+        if num_results >= 50:
+            raise ServiceInvalidRequestError("num_results value must be less than 50.")
+
+        if offset < 0:
+            raise ServiceInvalidRequestError("offset must be greater than 0.")
+
+        logger.info(
+            f"Received request for bing web search with \
+                params:\nquery: {query}\nnum_results: {num_results}\noffset: {offset}"
+        )
+
+        base_url = (
+            "https://api.bing.microsoft.com/v7.0/custom/search"
+            if self._settings.custom_config
+            else "https://api.bing.microsoft.com/v7.0/search"
+        )
+        request_url = f"{base_url}?q={urllib.parse.quote_plus(query)}&count={num_results}&offset={offset}" + (
+            f"&customConfig={self._settings.custom_config}" if self._settings.custom_config else ""
+        )
+
+        logger.info(f"Sending GET request to {request_url}")
+
+        if self._settings.api_key is not None:
+            headers = {"Ocp-Apim-Subscription-Key": self._settings.api_key.get_secret_value()}
+
+        try:
+            async with AsyncClient() as client:
+                response = await client.get(request_url, headers=headers)
+                response.raise_for_status()
+                data = response.json()
+                pages = data.get("webPages", {}).get("value")
+                if pages:
+                    return [page["snippet"] for page in pages]
+                return []
+        except HTTPStatusError as ex:
+            logger.error(f"Failed to get search results: {ex}")
+            raise ServiceInvalidRequestError("Failed to get search results.") from ex
+        except RequestError as ex:
+            logger.error(f"Client error occurred: {ex}")
+            raise ServiceInvalidRequestError("A client error occurred while getting search results.") from ex
+        except Exception as ex:
+            logger.error(f"An unexpected error occurred: {ex}")
+            raise ServiceInvalidRequestError("An unexpected error occurred while getting search results.") from ex

semantic_kernel-1.8.3/semantic_kernel/connectors/search_engine/bing_connector_settings.py

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from pydantic import SecretStr
+
+from semantic_kernel.kernel_pydantic import KernelBaseSettings
+
+
+class BingSettings(KernelBaseSettings):
+    """Bing Connector settings.
+
+    The settings are first loaded from environment variables with the prefix 'BING_'. If the
+    environment variables are not found, the settings can be loaded from a .env file with the
+    encoding 'utf-8'. If the settings are not found in the .env file, the settings are ignored;
+    however, validation will fail alerting that the settings are missing.
+
+    Optional settings for prefix 'BING_' are:
+    - api_key: SecretStr - The Bing API key (Env var BING_API_KEY)
+    - custom_config: str - The Bing Custom Search instance's unique identifier (Env var BING_CUSTOM_CONFIG)
+
+    """
+
+    env_prefix: ClassVar[str] = "BING_"
+
+    api_key: SecretStr
+    custom_config: str | None = None