semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/services/open_ai_chat_completion_base.py

@@ -0,0 +1,438 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import logging
+import sys
+from collections.abc import AsyncGenerator
+from functools import reduce
+from typing import TYPE_CHECKING, Any, ClassVar, cast
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from openai import AsyncStream
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, ChoiceDeltaFunctionCall, ChoiceDeltaToolCall
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
+from openai.types.chat.chat_completion_message import FunctionCall
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall
+from typing_extensions import deprecated
+
+from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
+from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior
+from semantic_kernel.connectors.ai.function_calling_utils import (
+    merge_function_results,
+    update_settings_from_function_call_configuration,
+)
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler
+from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.contents.function_call_content import FunctionCallContent
+from semantic_kernel.contents.streaming_chat_message_content import StreamingChatMessageContent
+from semantic_kernel.contents.streaming_text_content import StreamingTextContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.contents.utils.finish_reason import FinishReason
+from semantic_kernel.exceptions import ServiceInvalidExecutionSettingsError, ServiceInvalidResponseError
+from semantic_kernel.filters.auto_function_invocation.auto_function_invocation_context import (
+    AutoFunctionInvocationContext,
+)
+from semantic_kernel.utils.telemetry.model_diagnostics import trace_chat_completion
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+    from semantic_kernel.functions.kernel_arguments import KernelArguments
+    from semantic_kernel.kernel import Kernel
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class InvokeTermination(Exception):
+    """Exception for termination of function invocation."""
+
+    pass
+
+
+class OpenAIChatCompletionBase(OpenAIHandler, ChatCompletionClientBase):
+    """OpenAI Chat completion class."""
+
+    MODEL_PROVIDER_NAME: ClassVar[str] = "openai"
+
+    # region Overriding base class methods
+    # most of the methods are overridden from the ChatCompletionClientBase class, otherwise it is mentioned
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        return OpenAIChatPromptExecutionSettings
+
+    @override
+    @trace_chat_completion(MODEL_PROVIDER_NAME)
+    async def get_chat_message_contents(
+        self,
+        chat_history: ChatHistory,
+        settings: "PromptExecutionSettings",
+        **kwargs: Any,
+    ) -> list["ChatMessageContent"]:
+        if not isinstance(settings, OpenAIChatPromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, OpenAIChatPromptExecutionSettings)  # nosec
+
+        # For backwards compatibility we need to convert the `FunctionCallBehavior` to `FunctionChoiceBehavior`
+        # if this method is called with a `FunctionCallBehavior` object as part of the settings
+        if hasattr(settings, "function_call_behavior") and isinstance(
+            settings.function_call_behavior, FunctionCallBehavior
+        ):
+            settings.function_choice_behavior = FunctionChoiceBehavior.from_function_call_behavior(
+                settings.function_call_behavior
+            )
+
+        kernel = kwargs.get("kernel", None)
+        if settings.function_choice_behavior is not None:
+            if kernel is None:
+                raise ServiceInvalidExecutionSettingsError("The kernel is required for OpenAI tool calls.")
+            if settings.number_of_responses is not None and settings.number_of_responses > 1:
+                raise ServiceInvalidExecutionSettingsError(
+                    "Auto-invocation of tool calls may only be used with a "
+                    "OpenAIChatPromptExecutions.number_of_responses of 1."
+                )
+
+        # behavior for non-function calling or for enable, but not auto-invoke.
+        self._prepare_settings(settings, chat_history, stream_request=False, kernel=kernel)
+        if settings.function_choice_behavior is None or (
+            settings.function_choice_behavior and not settings.function_choice_behavior.auto_invoke_kernel_functions
+        ):
+            return await self._send_chat_request(settings)
+
+        # loop for auto-invoke function calls
+        for request_index in range(settings.function_choice_behavior.maximum_auto_invoke_attempts):
+            completions = await self._send_chat_request(settings)
+            # get the function call contents from the chat message, there is only one chat message
+            # this was checked earlier
+            function_calls = [item for item in completions[0].items if isinstance(item, FunctionCallContent)]
+            if (fc_count := len(function_calls)) == 0:
+                return completions
+
+            # Since we have a function call, add the assistant's tool call message to the history
+            chat_history.add_message(message=completions[0])
+
+            logger.info(f"processing {fc_count} tool calls in parallel.")
+
+            # this function either updates the chat history with the function call results
+            # or returns the context, with terminate set to True
+            # in which case the loop will break and the function calls are returned.
+            results = await asyncio.gather(
+                *[
+                    self._process_function_call(
+                        function_call=function_call,
+                        chat_history=chat_history,
+                        kernel=kernel,
+                        arguments=kwargs.get("arguments", None),
+                        function_call_count=fc_count,
+                        request_index=request_index,
+                        function_call_behavior=settings.function_choice_behavior,
+                    )
+                    for function_call in function_calls
+                ],
+            )
+
+            if any(result.terminate for result in results if result is not None):
+                return merge_function_results(chat_history.messages[-len(results) :])
+
+            self._update_settings(settings, chat_history, kernel=kernel)
+        else:
+            # do a final call, without function calling when the max has been reached.
+            settings.function_choice_behavior.auto_invoke_kernel_functions = False
+            return await self._send_chat_request(settings)
+
+    @override
+    async def get_streaming_chat_message_contents(
+        self,
+        chat_history: ChatHistory,
+        settings: "PromptExecutionSettings",
+        **kwargs: Any,
+    ) -> AsyncGenerator[list[StreamingChatMessageContent], Any]:
+        if not isinstance(settings, OpenAIChatPromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, OpenAIChatPromptExecutionSettings)  # nosec
+
+        # For backwards compatibility we need to convert the `FunctionCallBehavior` to `FunctionChoiceBehavior`
+        # if this method is called with a `FunctionCallBehavior` object as part of the settings
+        if hasattr(settings, "function_call_behavior") and isinstance(
+            settings.function_call_behavior, FunctionCallBehavior
+        ):
+            settings.function_choice_behavior = FunctionChoiceBehavior.from_function_call_behavior(
+                settings.function_call_behavior
+            )
+
+        kernel = kwargs.get("kernel", None)
+        if settings.function_choice_behavior is not None:
+            if kernel is None:
+                raise ServiceInvalidExecutionSettingsError("The kernel is required for OpenAI tool calls.")
+            if settings.number_of_responses is not None and settings.number_of_responses > 1:
+                raise ServiceInvalidExecutionSettingsError(
+                    "Auto-invocation of tool calls may only be used with a "
+                    "OpenAIChatPromptExecutions.number_of_responses of 1."
+                )
+
+        # Prepare settings for streaming requests
+        self._prepare_settings(settings, chat_history, stream_request=True, kernel=kernel)
+
+        request_attempts = (
+            settings.function_choice_behavior.maximum_auto_invoke_attempts
+            if (settings.function_choice_behavior and settings.function_choice_behavior.auto_invoke_kernel_functions)
+            else 1
+        )
+        # hold the messages, if there are more than one response, it will not be used, so we flatten
+        for request_index in range(request_attempts):
+            all_messages: list[StreamingChatMessageContent] = []
+            function_call_returned = False
+            async for messages in self._send_chat_stream_request(settings):
+                for msg in messages:
+                    if msg is not None:
+                        all_messages.append(msg)
+                        if any(isinstance(item, FunctionCallContent) for item in msg.items):
+                            function_call_returned = True
+                yield messages
+
+            if (
+                settings.function_choice_behavior is None
+                or (
+                    settings.function_choice_behavior
+                    and not settings.function_choice_behavior.auto_invoke_kernel_functions
+                )
+                or not function_call_returned
+            ):
+                # no need to process function calls
+                # note that we don't check the FinishReason and instead check whether there are any tool calls,
+                # as the service may return a FinishReason of "stop" even if there are tool calls to be made,
+                # in particular if a required tool is specified.
+                return
+
+            # there is one response stream in the messages, combining now to create the full completion
+            # depending on the prompt, the message may contain both function call content and others
+            full_completion: StreamingChatMessageContent = reduce(lambda x, y: x + y, all_messages)
+            function_calls = [item for item in full_completion.items if isinstance(item, FunctionCallContent)]
+            chat_history.add_message(message=full_completion)
+
+            fc_count = len(function_calls)
+            logger.info(f"processing {fc_count} tool calls in parallel.")
+
+            # this function either updates the chat history with the function call results
+            # or returns the context, with terminate set to True
+            # in which case the loop will break and the function calls are returned.
+            # Exceptions are not caught, that is up to the developer, can be done with a filter
+            results = await asyncio.gather(
+                *[
+                    self._process_function_call(
+                        function_call=function_call,
+                        chat_history=chat_history,
+                        kernel=kernel,
+                        arguments=kwargs.get("arguments", None),
+                        function_call_count=fc_count,
+                        request_index=request_index,
+                        function_call_behavior=settings.function_choice_behavior,
+                    )
+                    for function_call in function_calls
+                ],
+            )
+            if any(result.terminate for result in results if result is not None):
+                yield merge_function_results(chat_history.messages[-len(results) :])  # type: ignore
+                break
+
+            self._update_settings(settings, chat_history, kernel=kernel)
+
+    # endregion
+    # region internal handlers
+
+    async def _send_chat_request(self, settings: OpenAIChatPromptExecutionSettings) -> list["ChatMessageContent"]:
+        """Send the chat request."""
+        response = await self._send_request(request_settings=settings)
+        assert isinstance(response, ChatCompletion)  # nosec
+        response_metadata = self._get_metadata_from_chat_response(response)
+        return [self._create_chat_message_content(response, choice, response_metadata) for choice in response.choices]
+
+    async def _send_chat_stream_request(
+        self, settings: OpenAIChatPromptExecutionSettings
+    ) -> AsyncGenerator[list["StreamingChatMessageContent"], None]:
+        """Send the chat stream request."""
+        response = await self._send_request(request_settings=settings)
+        if not isinstance(response, AsyncStream):
+            raise ServiceInvalidResponseError("Expected an AsyncStream[ChatCompletionChunk] response.")
+        async for chunk in response:
+            if len(chunk.choices) == 0:
+                continue
+            assert isinstance(chunk, ChatCompletionChunk)  # nosec
+            chunk_metadata = self._get_metadata_from_streaming_chat_response(chunk)
+            yield [
+                self._create_streaming_chat_message_content(chunk, choice, chunk_metadata) for choice in chunk.choices
+            ]
+
+    # endregion
+    # region content creation
+
+    def _create_chat_message_content(
+        self, response: ChatCompletion, choice: Choice, response_metadata: dict[str, Any]
+    ) -> "ChatMessageContent":
+        """Create a chat message content object from a choice."""
+        metadata = self._get_metadata_from_chat_choice(choice)
+        metadata.update(response_metadata)
+
+        items: list[Any] = self._get_tool_calls_from_chat_choice(choice)
+        items.extend(self._get_function_call_from_chat_choice(choice))
+        if choice.message.content:
+            items.append(TextContent(text=choice.message.content))
+
+        return ChatMessageContent(
+            inner_content=response,
+            ai_model_id=self.ai_model_id,
+            metadata=metadata,
+            role=AuthorRole(choice.message.role),
+            items=items,
+            finish_reason=(FinishReason(choice.finish_reason) if choice.finish_reason else None),
+        )
+
+    def _create_streaming_chat_message_content(
+        self,
+        chunk: ChatCompletionChunk,
+        choice: ChunkChoice,
+        chunk_metadata: dict[str, Any],
+    ) -> StreamingChatMessageContent:
+        """Create a streaming chat message content object from a choice."""
+        metadata = self._get_metadata_from_chat_choice(choice)
+        metadata.update(chunk_metadata)
+
+        items: list[Any] = self._get_tool_calls_from_chat_choice(choice)
+        items.extend(self._get_function_call_from_chat_choice(choice))
+        if choice.delta and choice.delta.content is not None:
+            items.append(StreamingTextContent(choice_index=choice.index, text=choice.delta.content))
+        return StreamingChatMessageContent(
+            choice_index=choice.index,
+            inner_content=chunk,
+            ai_model_id=self.ai_model_id,
+            metadata=metadata,
+            role=(AuthorRole(choice.delta.role) if choice.delta and choice.delta.role else AuthorRole.ASSISTANT),
+            finish_reason=(FinishReason(choice.finish_reason) if choice.finish_reason else None),
+            items=items,
+        )
+
+    def _get_metadata_from_chat_response(self, response: ChatCompletion) -> dict[str, Any]:
+        """Get metadata from a chat response."""
+        return {
+            "id": response.id,
+            "created": response.created,
+            "system_fingerprint": response.system_fingerprint,
+            "usage": response.usage if hasattr(response, "usage") else None,
+        }
+
+    def _get_metadata_from_streaming_chat_response(self, response: ChatCompletionChunk) -> dict[str, Any]:
+        """Get metadata from a streaming chat response."""
+        return {
+            "id": response.id,
+            "created": response.created,
+            "system_fingerprint": response.system_fingerprint,
+        }
+
+    def _get_metadata_from_chat_choice(self, choice: Choice | ChunkChoice) -> dict[str, Any]:
+        """Get metadata from a chat choice."""
+        return {
+            "logprobs": getattr(choice, "logprobs", None),
+        }
+
+    def _get_tool_calls_from_chat_choice(self, choice: Choice | ChunkChoice) -> list[FunctionCallContent]:
+        """Get tool calls from a chat choice."""
+        content = choice.message if isinstance(choice, Choice) else choice.delta
+        if content and (tool_calls := getattr(content, "tool_calls", None)) is not None:
+            return [
+                FunctionCallContent(
+                    id=tool.id,
+                    index=getattr(tool, "index", None),
+                    name=tool.function.name,
+                    arguments=tool.function.arguments,
+                )
+                for tool in cast(list[ChatCompletionMessageToolCall] | list[ChoiceDeltaToolCall], tool_calls)
+                if tool.function is not None
+            ]
+        # When you enable asynchronous content filtering in Azure OpenAI, you may receive empty deltas
+        return []
+
+    def _get_function_call_from_chat_choice(self, choice: Choice | ChunkChoice) -> list[FunctionCallContent]:
+        """Get a function call from a chat choice."""
+        content = choice.message if isinstance(choice, Choice) else choice.delta
+        if content and (function_call := getattr(content, "function_call", None)) is not None:
+            function_call = cast(FunctionCall | ChoiceDeltaFunctionCall, function_call)
+            return [
+                FunctionCallContent(
+                    id="legacy_function_call", name=function_call.name, arguments=function_call.arguments
+                )
+            ]
+        # When you enable asynchronous content filtering in Azure OpenAI, you may receive empty deltas
+        return []
+
+    # endregion
+    # region request preparation
+
+    def _prepare_settings(
+        self,
+        settings: OpenAIChatPromptExecutionSettings,
+        chat_history: ChatHistory,
+        stream_request: bool = False,
+        kernel: "Kernel | None" = None,
+    ) -> None:
+        """Prepare the prompt execution settings for the chat request."""
+        settings.stream = stream_request
+        if not settings.ai_model_id:
+            settings.ai_model_id = self.ai_model_id
+        self._update_settings(settings=settings, chat_history=chat_history, kernel=kernel)
+
+    def _update_settings(
+        self,
+        settings: OpenAIChatPromptExecutionSettings,
+        chat_history: ChatHistory,
+        kernel: "Kernel | None" = None,
+    ) -> None:
+        """Update the settings with the chat history."""
+        settings.messages = self._prepare_chat_history_for_request(chat_history)
+        if settings.function_choice_behavior and kernel:
+            settings.function_choice_behavior.configure(
+                kernel=kernel,
+                update_settings_callback=update_settings_from_function_call_configuration,
+                settings=settings,
+            )
+
+    # endregion
+    # region function calling
+
+    @deprecated("Use `invoke_function_call` from the kernel instead with `FunctionChoiceBehavior`.")
+    async def _process_function_call(
+        self,
+        function_call: FunctionCallContent,
+        chat_history: ChatHistory,
+        kernel: "Kernel",
+        arguments: "KernelArguments | None",
+        function_call_count: int,
+        request_index: int,
+        function_call_behavior: FunctionChoiceBehavior | FunctionCallBehavior,
+    ) -> "AutoFunctionInvocationContext | None":
+        """Processes the tool calls in the result and update the chat history."""
+        # deprecated and might not even be used anymore, hard to trigger directly
+        if isinstance(function_call_behavior, FunctionCallBehavior):  # pragma: no cover
+            # We need to still support a `FunctionCallBehavior` input so it doesn't break current
+            # customers. Map from `FunctionCallBehavior` -> `FunctionChoiceBehavior`
+            function_call_behavior = FunctionChoiceBehavior.from_function_call_behavior(function_call_behavior)
+
+        return await kernel.invoke_function_call(
+            function_call=function_call,
+            chat_history=chat_history,
+            arguments=arguments,
+            function_call_count=function_call_count,
+            request_index=request_index,
+            function_behavior=function_call_behavior,
+        )
+
+    # endregion

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/services/open_ai_config_base.py

@@ -0,0 +1,98 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Mapping
+from copy import copy
+
+from openai import AsyncOpenAI
+from pydantic import ConfigDict, Field, validate_call
+
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_model_types import OpenAIModelTypes
+from semantic_kernel.const import USER_AGENT
+from semantic_kernel.exceptions import ServiceInitializationError
+from semantic_kernel.utils.telemetry.user_agent import APP_INFO, prepend_semantic_kernel_to_user_agent
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OpenAIConfigBase(OpenAIHandler):
+    """Internal class for configuring a connection to an OpenAI service."""
+
+    @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+    def __init__(
+        self,
+        ai_model_id: str = Field(min_length=1),
+        api_key: str | None = Field(min_length=1),
+        ai_model_type: OpenAIModelTypes | None = OpenAIModelTypes.CHAT,
+        org_id: str | None = None,
+        service_id: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        client: AsyncOpenAI | None = None,
+    ) -> None:
+        """Initialize a client for OpenAI services.
+
+        This constructor sets up a client to interact with OpenAI's API, allowing for
+        different types of AI model interactions, like chat or text completion.
+
+        Args:
+            ai_model_id (str): OpenAI model identifier. Must be non-empty.
+                Default to a preset value.
+            api_key (str): OpenAI API key for authentication.
+                Must be non-empty. (Optional)
+            ai_model_type (OpenAIModelTypes): The type of OpenAI
+                model to interact with. Defaults to CHAT.
+            org_id (str): OpenAI organization ID. This is optional
+                unless the account belongs to multiple organizations.
+            service_id (str): OpenAI service ID. This is optional.
+            default_headers (Mapping[str, str]): Default headers
+                for HTTP requests. (Optional)
+            client (AsyncOpenAI): An existing OpenAI client, optional.
+
+        """
+        # Merge APP_INFO into the headers if it exists
+        merged_headers = dict(copy(default_headers)) if default_headers else {}
+        if APP_INFO:
+            merged_headers.update(APP_INFO)
+            merged_headers = prepend_semantic_kernel_to_user_agent(merged_headers)
+
+        if not client:
+            if not api_key:
+                raise ServiceInitializationError("Please provide an api_key")
+            client = AsyncOpenAI(
+                api_key=api_key,
+                organization=org_id,
+                default_headers=merged_headers,
+            )
+        args = {
+            "ai_model_id": ai_model_id,
+            "client": client,
+            "ai_model_type": ai_model_type,
+        }
+        if service_id:
+            args["service_id"] = service_id
+        super().__init__(**args)
+
+    def to_dict(self) -> dict[str, str]:
+        """Create a dict of the service settings."""
+        client_settings = {
+            "api_key": self.client.api_key,
+            "default_headers": {k: v for k, v in self.client.default_headers.items() if k != USER_AGENT},
+        }
+        if self.client.organization:
+            client_settings["org_id"] = self.client.organization
+        base = self.model_dump(
+            exclude={
+                "prompt_tokens",
+                "completion_tokens",
+                "total_tokens",
+                "api_type",
+                "ai_model_type",
+                "service_id",
+                "client",
+            },
+            by_alias=True,
+            exclude_none=True,
+        )
+        base.update(client_settings)
+        return base

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/services/open_ai_handler.py

@@ -0,0 +1,85 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from abc import ABC
+from typing import Any
+
+from openai import AsyncOpenAI, AsyncStream, BadRequestError
+from openai.types import Completion, CreateEmbeddingResponse
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
+
+from semantic_kernel.connectors.ai.open_ai.exceptions.content_filter_ai_exception import ContentFilterAIException
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIEmbeddingPromptExecutionSettings,
+    OpenAIPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_model_types import OpenAIModelTypes
+from semantic_kernel.exceptions import ServiceResponseException
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OpenAIHandler(KernelBaseModel, ABC):
+    """Internal class for calls to OpenAI API's."""
+
+    client: AsyncOpenAI
+    ai_model_type: OpenAIModelTypes = OpenAIModelTypes.CHAT
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+    async def _send_request(
+        self,
+        request_settings: OpenAIPromptExecutionSettings,
+    ) -> ChatCompletion | Completion | AsyncStream[ChatCompletionChunk] | AsyncStream[Completion]:
+        """Execute the appropriate call to OpenAI models."""
+        try:
+            if self.ai_model_type == OpenAIModelTypes.CHAT:
+                response = await self.client.chat.completions.create(**request_settings.prepare_settings_dict())
+            else:
+                response = await self.client.completions.create(**request_settings.prepare_settings_dict())
+            self.store_usage(response)
+            return response
+        except BadRequestError as ex:
+            if ex.code == "content_filter":
+                raise ContentFilterAIException(
+                    f"{type(self)} service encountered a content error",
+                    ex,
+                ) from ex
+            raise ServiceResponseException(
+                f"{type(self)} service failed to complete the prompt",
+                ex,
+            ) from ex
+        except Exception as ex:
+            raise ServiceResponseException(
+                f"{type(self)} service failed to complete the prompt",
+                ex,
+            ) from ex
+
+    async def _send_embedding_request(self, settings: OpenAIEmbeddingPromptExecutionSettings) -> list[Any]:
+        try:
+            response = await self.client.embeddings.create(**settings.prepare_settings_dict())
+            self.store_usage(response)
+            return [x.embedding for x in response.data]
+        except Exception as ex:
+            raise ServiceResponseException(
+                f"{type(self)} service failed to generate embeddings",
+                ex,
+            ) from ex
+
+    def store_usage(
+        self,
+        response: ChatCompletion
+        | Completion
+        | AsyncStream[ChatCompletionChunk]
+        | AsyncStream[Completion]
+        | CreateEmbeddingResponse,
+    ):
+        """Store the usage information from the response."""
+        if not isinstance(response, AsyncStream) and response.usage:
+            logger.info(f"OpenAI usage: {response.usage}")
+            self.prompt_tokens += response.usage.prompt_tokens
+            self.total_tokens += response.usage.total_tokens
+            if hasattr(response.usage, "completion_tokens"):
+                self.completion_tokens += response.usage.completion_tokens

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/services/open_ai_model_types.py

@@ -0,0 +1,12 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from enum import Enum
+
+
+class OpenAIModelTypes(Enum):
+    """OpenAI model types, can be text, chat or embedding."""
+
+    TEXT = "text"
+    CHAT = "chat"
+    EMBEDDING = "embedding"
+    IMAGE = "image"