semantic-kernel 1.8.3__zip

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

@@ -0,0 +1,89 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import json
+import logging
+from collections.abc import Mapping
+from typing import Any
+
+from openai import AsyncOpenAI
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_config_base import OpenAIConfigBase
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIModelTypes
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_completion_base import OpenAITextCompletionBase
+from semantic_kernel.connectors.ai.open_ai.settings.open_ai_settings import OpenAISettings
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OpenAITextCompletion(OpenAITextCompletionBase, OpenAIConfigBase):
+    """OpenAI Text Completion class."""
+
+    def __init__(
+        self,
+        ai_model_id: str | None = None,
+        api_key: str | None = None,
+        org_id: str | None = None,
+        service_id: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        async_client: AsyncOpenAI | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an OpenAITextCompletion service.
+
+        Args:
+            ai_model_id (str | None): OpenAI model name, see
+                https://platform.openai.com/docs/models
+            service_id (str | None): Service ID tied to the execution settings.
+            api_key (str | None): The optional API key to use. If provided will override,
+                the env vars or .env file value.
+            org_id (str | None): The optional org ID to use. If provided will override,
+                the env vars or .env file value.
+            default_headers: The default headers mapping of string keys to
+                string values for HTTP requests. (Optional)
+            async_client (Optional[AsyncOpenAI]): An existing client to use. (Optional)
+            env_file_path (str | None): Use the environment settings file as a fallback to
+                environment variables. (Optional)
+            env_file_encoding (str | None): The encoding of the environment settings file. (Optional)
+        """
+        try:
+            openai_settings = OpenAISettings.create(
+                api_key=api_key,
+                org_id=org_id,
+                text_model_id=ai_model_id,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create OpenAI settings.", ex) from ex
+        if not openai_settings.text_model_id:
+            raise ServiceInitializationError("The OpenAI text model ID is required.")
+        super().__init__(
+            ai_model_id=openai_settings.text_model_id,
+            service_id=service_id,
+            api_key=openai_settings.api_key.get_secret_value() if openai_settings.api_key else None,
+            org_id=openai_settings.org_id,
+            ai_model_type=OpenAIModelTypes.TEXT,
+            default_headers=default_headers,
+            client=async_client,
+        )
+
+    @classmethod
+    def from_dict(cls, settings: dict[str, Any]) -> "OpenAITextCompletion":
+        """Initialize an Open AI service from a dictionary of settings.
+
+        Args:
+            settings: A dictionary of settings for the service.
+        """
+        if "default_headers" in settings and isinstance(settings["default_headers"], str):
+            settings["default_headers"] = json.loads(settings["default_headers"])
+        return OpenAITextCompletion(
+            ai_model_id=settings.get("ai_model_id"),
+            api_key=settings.get("api_key"),
+            org_id=settings.get("org_id"),
+            service_id=settings.get("service_id"),
+            default_headers=settings.get("default_headers"),
+            env_file_path=settings.get("env_file_path"),
+        )

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

@@ -0,0 +1,149 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Any, ClassVar
+
+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 import Completion as TextCompletion
+from openai.types import CompletionChoice as TextCompletionChoice
+from openai.types.chat.chat_completion import ChatCompletion
+from openai.types.chat.chat_completion import Choice as ChatCompletionChoice
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_chunk import Choice as ChatCompletionChunkChoice
+
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIChatPromptExecutionSettings,
+    OpenAITextPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler
+from semantic_kernel.connectors.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.contents.streaming_text_content import StreamingTextContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.utils.telemetry.model_diagnostics import trace_text_completion
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OpenAITextCompletionBase(OpenAIHandler, TextCompletionClientBase):
+    """Base class for OpenAI text completion services."""
+
+    MODEL_PROVIDER_NAME: ClassVar[str] = "openai"
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        return OpenAITextPromptExecutionSettings
+
+    @override
+    @trace_text_completion(MODEL_PROVIDER_NAME)
+    async def get_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> list["TextContent"]:
+        if not isinstance(settings, (OpenAITextPromptExecutionSettings, OpenAIChatPromptExecutionSettings)):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, (OpenAITextPromptExecutionSettings, OpenAIChatPromptExecutionSettings))  # nosec
+        if isinstance(settings, OpenAITextPromptExecutionSettings):
+            settings.prompt = prompt
+        else:
+            settings.messages = [{"role": "user", "content": prompt}]
+        if settings.ai_model_id is None:
+            settings.ai_model_id = self.ai_model_id
+        response = await self._send_request(request_settings=settings)
+        assert isinstance(response, (TextCompletion, ChatCompletion))  # nosec
+        metadata = self._get_metadata_from_text_response(response)
+        return [self._create_text_content(response, choice, metadata) for choice in response.choices]
+
+    @override
+    async def get_streaming_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> AsyncGenerator[list["StreamingTextContent"], Any]:
+        if not isinstance(settings, (OpenAITextPromptExecutionSettings, OpenAIChatPromptExecutionSettings)):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, (OpenAITextPromptExecutionSettings, OpenAIChatPromptExecutionSettings))  # nosec
+
+        if isinstance(settings, OpenAITextPromptExecutionSettings):
+            settings.prompt = prompt
+        else:
+            if not settings.messages:
+                settings.messages = [{"role": "user", "content": prompt}]
+            else:
+                settings.messages.append({"role": "user", "content": prompt})
+        settings.ai_model_id = self.ai_model_id
+        settings.stream = True
+        response = await self._send_request(request_settings=settings)
+        assert isinstance(response, AsyncStream)  # nosec
+        async for chunk in response:
+            if len(chunk.choices) == 0:
+                continue
+            assert isinstance(chunk, (TextCompletion, ChatCompletionChunk))  # nosec
+            chunk_metadata = self._get_metadata_from_text_response(chunk)
+            yield [self._create_streaming_text_content(chunk, choice, chunk_metadata) for choice in chunk.choices]
+
+    def _create_text_content(
+        self,
+        response: TextCompletion | ChatCompletion,
+        choice: TextCompletionChoice | ChatCompletionChoice,
+        response_metadata: dict[str, Any],
+    ) -> "TextContent":
+        """Create a text content object from a choice."""
+        choice_metadata = self._get_metadata_from_text_choice(choice)
+        choice_metadata.update(response_metadata)
+        text = choice.text if isinstance(choice, TextCompletionChoice) else choice.message.content
+        return TextContent(
+            inner_content=response,
+            ai_model_id=self.ai_model_id,
+            text=text or "",
+            metadata=choice_metadata,
+        )
+
+    def _create_streaming_text_content(
+        self,
+        chunk: TextCompletion | ChatCompletionChunk,
+        choice: TextCompletionChoice | ChatCompletionChunkChoice,
+        response_metadata: dict[str, Any],
+    ) -> "StreamingTextContent":
+        """Create a streaming text content object from a choice."""
+        choice_metadata = self._get_metadata_from_text_choice(choice)
+        choice_metadata.update(response_metadata)
+        text = choice.text if isinstance(choice, TextCompletionChoice) else choice.delta.content
+        return StreamingTextContent(
+            choice_index=choice.index,
+            inner_content=chunk,
+            ai_model_id=self.ai_model_id,
+            metadata=choice_metadata,
+            text=text or "",
+        )
+
+    def _get_metadata_from_text_response(
+        self, response: TextCompletion | ChatCompletion | ChatCompletionChunk
+    ) -> dict[str, Any]:
+        """Get metadata from a response."""
+        ret = {
+            "id": response.id,
+            "created": response.created,
+            "system_fingerprint": response.system_fingerprint,
+        }
+        if hasattr(response, "usage"):
+            ret["usage"] = response.usage
+        return ret
+
+    def _get_metadata_from_text_choice(
+        self, choice: TextCompletionChoice | ChatCompletionChoice | ChatCompletionChunkChoice
+    ) -> dict[str, Any]:
+        """Get metadata from a completion choice."""
+        return {
+            "logprobs": getattr(choice, "logprobs", None),
+        }

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

@@ -0,0 +1,90 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from openai import AsyncOpenAI
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_config_base import OpenAIConfigBase
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIModelTypes
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_embedding_base import OpenAITextEmbeddingBase
+from semantic_kernel.connectors.ai.open_ai.settings.open_ai_settings import OpenAISettings
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+T_ = TypeVar("T_", bound="OpenAITextEmbedding")
+
+
+@experimental_class
+class OpenAITextEmbedding(OpenAIConfigBase, OpenAITextEmbeddingBase):
+    """OpenAI Text Embedding class."""
+
+    def __init__(
+        self,
+        ai_model_id: str | None = None,
+        api_key: str | None = None,
+        org_id: str | None = None,
+        service_id: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        async_client: AsyncOpenAI | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initializes a new instance of the OpenAITextCompletion class.
+
+        Args:
+            ai_model_id (str): OpenAI model name, see
+                https://platform.openai.com/docs/models
+            service_id (str | None): Service ID tied to the execution settings.
+            api_key (str | None): The optional API key to use. If provided will override,
+                the env vars or .env file value.
+            org_id (str | None): The optional org ID to use. If provided will override,
+                the env vars or .env file value.
+            default_headers (Mapping[str,str] | None): The default headers mapping of string keys to
+                string values for HTTP requests. (Optional)
+            async_client (Optional[AsyncOpenAI]): An existing client to use. (Optional)
+            env_file_path (str | None): Use the environment settings file as
+                a fallback to environment variables. (Optional)
+            env_file_encoding (str | None): The encoding of the environment settings file. (Optional)
+        """
+        try:
+            openai_settings = OpenAISettings.create(
+                api_key=api_key,
+                org_id=org_id,
+                embedding_model_id=ai_model_id,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create OpenAI settings.", ex) from ex
+        if not openai_settings.embedding_model_id:
+            raise ServiceInitializationError("The OpenAI embedding model ID is required.")
+        super().__init__(
+            ai_model_id=openai_settings.embedding_model_id,
+            api_key=openai_settings.api_key.get_secret_value() if openai_settings.api_key else None,
+            ai_model_type=OpenAIModelTypes.EMBEDDING,
+            org_id=openai_settings.org_id,
+            service_id=service_id,
+            default_headers=default_headers,
+            client=async_client,
+        )
+
+    @classmethod
+    def from_dict(cls: type[T_], settings: dict[str, Any]) -> T_:
+        """Initialize an Open AI service from a dictionary of settings.
+
+        Args:
+            settings: A dictionary of settings for the service.
+        """
+        return cls(
+            ai_model_id=settings.get("ai_model_id"),
+            api_key=settings.get("api_key"),
+            org_id=settings.get("org_id"),
+            service_id=settings.get("service_id"),
+            default_headers=settings.get("default_headers", {}),
+            env_file_path=settings.get("env_file_path"),
+        )

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

@@ -0,0 +1,76 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from numpy import array, ndarray
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import EmbeddingGeneratorBase
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIEmbeddingPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+
+@experimental_class
+class OpenAITextEmbeddingBase(OpenAIHandler, EmbeddingGeneratorBase):
+    """Base class for OpenAI text embedding services."""
+
+    @override
+    async def generate_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        batch_size: int | None = None,
+        **kwargs: Any,
+    ) -> ndarray:
+        raw_embeddings = await self.generate_raw_embeddings(texts, settings, batch_size, **kwargs)
+        return array(raw_embeddings)
+
+    @override
+    async def generate_raw_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        batch_size: int | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Returns embeddings for the given texts in the unedited format.
+
+        Args:
+            texts (List[str]): The texts to generate embeddings for.
+            settings (PromptExecutionSettings): The settings to use for the request.
+            batch_size (int): The batch size to use for the request.
+            kwargs (Dict[str, Any]): Additional arguments to pass to the request.
+        """
+        if not settings:
+            settings = OpenAIEmbeddingPromptExecutionSettings(ai_model_id=self.ai_model_id)
+        else:
+            if not isinstance(settings, OpenAIEmbeddingPromptExecutionSettings):
+                settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, OpenAIEmbeddingPromptExecutionSettings)  # nosec
+        if settings.ai_model_id is None:
+            settings.ai_model_id = self.ai_model_id
+        for key, value in kwargs.items():
+            setattr(settings, key, value)
+        raw_embeddings = []
+        batch_size = batch_size or len(texts)
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i : i + batch_size]
+            settings.input = batch
+            raw_embedding = await self._send_embedding_request(settings=settings)
+            raw_embeddings.extend(raw_embedding)
+        return raw_embeddings
+
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        """Get the request settings class."""
+        return OpenAIEmbeddingPromptExecutionSettings

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

@@ -0,0 +1,85 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from openai import AsyncOpenAI
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_config_base import OpenAIConfigBase
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_model_types import OpenAIModelTypes
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_to_image_base import OpenAITextToImageBase
+from semantic_kernel.connectors.ai.open_ai.settings.open_ai_settings import OpenAISettings
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+
+T_ = TypeVar("T_", bound="OpenAITextToImage")
+
+
+class OpenAITextToImage(OpenAIConfigBase, OpenAITextToImageBase):
+    """OpenAI Text to Image service."""
+
+    def __init__(
+        self,
+        ai_model_id: str | None = None,
+        api_key: str | None = None,
+        org_id: str | None = None,
+        service_id: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        async_client: AsyncOpenAI | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initializes a new instance of the OpenAITextCompletion class.
+
+        Args:
+            ai_model_id: OpenAI model name, see
+                https://platform.openai.com/docs/models
+            service_id: Service ID tied to the execution settings.
+            api_key: The optional API key to use. If provided will override,
+                the env vars or .env file value.
+            org_id: The optional org ID to use. If provided will override,
+                the env vars or .env file value.
+            default_headers: The default headers mapping of string keys to
+                string values for HTTP requests. (Optional)
+            async_client: An existing client to use. (Optional)
+            env_file_path: Use the environment settings file as
+                a fallback to environment variables. (Optional)
+            env_file_encoding: The encoding of the environment settings file. (Optional)
+        """
+        try:
+            openai_settings = OpenAISettings.create(
+                api_key=api_key,
+                org_id=org_id,
+                text_to_image_model_id=ai_model_id,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create OpenAI settings.", ex) from ex
+        if not openai_settings.text_to_image_model_id:
+            raise ServiceInitializationError("The OpenAI text to image model ID is required.")
+        super().__init__(
+            ai_model_id=openai_settings.text_to_image_model_id,
+            api_key=openai_settings.api_key.get_secret_value() if openai_settings.api_key else None,
+            ai_model_type=OpenAIModelTypes.IMAGE,
+            org_id=openai_settings.org_id,
+            service_id=service_id,
+            default_headers=default_headers,
+            client=async_client,
+        )
+
+    @classmethod
+    def from_dict(cls: type[T_], settings: dict[str, Any]) -> T_:
+        """Initialize an Open AI service from a dictionary of settings.
+
+        Args:
+            settings: A dictionary of settings for the service.
+        """
+        return cls(
+            ai_model_id=settings.get("ai_model_id"),
+            api_key=settings.get("api_key"),
+            org_id=settings.get("org_id"),
+            service_id=settings.get("service_id"),
+            default_headers=settings.get("default_headers", {}),
+            env_file_path=settings.get("env_file_path"),
+        )

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

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Any
+
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler
+from semantic_kernel.connectors.ai.text_to_image_client_base import TextToImageClientBase
+from semantic_kernel.exceptions.service_exceptions import ServiceResponseException
+
+
+class OpenAITextToImageBase(OpenAIHandler, TextToImageClientBase):
+    """OpenAI text to image client."""
+
+    async def generate_image(self, description: str, width: int, height: int, **kwargs: Any) -> bytes | str:
+        """Generate image from text.
+
+        Args:
+            description: Description of the image.
+            width: Width of the image, check the openai documentation for the supported sizes.
+            height: Height of the image, check the openai documentation for the supported sizes.
+            kwargs: Additional arguments, check the openai images.generate documentation for the supported arguments.
+
+        Returns:
+            bytes | str: Image bytes or image URL.
+        """
+        try:
+            result = await self.client.images.generate(
+                prompt=description,
+                model=self.ai_model_id,
+                size=f"{width}x{height}",  # type: ignore
+                response_format="url",
+                **kwargs,
+            )
+        except Exception as ex:
+            raise ServiceResponseException(f"Failed to generate image: {ex}") from ex
+        if not result.data or not result.data[0].url:
+            raise ServiceResponseException("Failed to generate image.")
+        return result.data[0].url

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/settings/azure_open_ai_settings.py

@@ -0,0 +1,74 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from typing import ClassVar
+
+from pydantic import SecretStr
+
+from semantic_kernel.connectors.ai.open_ai.const import DEFAULT_AZURE_API_VERSION
+from semantic_kernel.kernel_pydantic import HttpsUrl, KernelBaseSettings
+
+
+class AzureOpenAISettings(KernelBaseSettings):
+    """AzureOpenAI model settings.
+
+    The settings are first loaded from environment variables with the prefix 'AZURE_OPENAI_'.
+    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 'AZURE_OPENAI_' are:
+    - chat_deployment_name: str - The name of the Azure Chat deployment. This value
+                will correspond to the custom name you chose for your deployment
+                when you deployed a model. This value can be found under
+                Resource Management > Deployments in the Azure portal or, alternatively,
+                under Management > Deployments in Azure OpenAI Studio.
+                (Env var AZURE_OPENAI_CHAT_DEPLOYMENT_NAME)
+    - text_deployment_name: str - The name of the Azure Text deployment. This value
+                will correspond to the custom name you chose for your deployment
+                when you deployed a model. This value can be found under
+                Resource Management > Deployments in the Azure portal or, alternatively,
+                under Management > Deployments in Azure OpenAI Studio.
+                (Env var AZURE_OPENAI_TEXT_DEPLOYMENT_NAME)
+    - embedding_deployment_name: str - The name of the Azure Embedding deployment. This value
+                will correspond to the custom name you chose for your deployment
+                when you deployed a model. This value can be found under
+                Resource Management > Deployments in the Azure portal or, alternatively,
+                under Management > Deployments in Azure OpenAI Studio.
+                (Env var AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME)
+    - text_to_image_deployment_name: str - The name of the Azure Text to Image deployment. This
+                value will correspond to the custom name you chose for your deployment
+                when you deployed a model. This value can be found under
+                Resource Management > Deployments in the Azure portal or, alternatively,
+                under Management > Deployments in Azure OpenAI Studio.
+                (Env var AZURE_OPENAI_TEXT_TO_IMAGE_DEPLOYMENT_NAME)
+    - api_key: SecretStr - The API key for the Azure deployment. This value can be
+                found in the Keys & Endpoint section when examining your resource in
+                the Azure portal. You can use either KEY1 or KEY2.
+                (Env var AZURE_OPENAI_API_KEY)
+    - base_url: HttpsUrl | None - base_url: The url of the Azure deployment. This value
+                can be found in the Keys & Endpoint section when examining
+                your resource from the Azure portal, the base_url consists of the endpoint,
+                followed by /openai/deployments/{deployment_name}/,
+                use endpoint if you only want to supply the endpoint.
+                (Env var AZURE_OPENAI_BASE_URL)
+    - endpoint: HttpsUrl - The endpoint of the Azure deployment. This value
+                can be found in the Keys & Endpoint section when examining
+                your resource from the Azure portal, the endpoint should end in openai.azure.com.
+                If both base_url and endpoint are supplied, base_url will be used.
+                (Env var AZURE_OPENAI_ENDPOINT)
+    - api_version: str | None - The API version to use. The default value is "2024-02-01".
+                (Env var AZURE_OPENAI_API_VERSION)
+    - env_file_path: str | None - if provided, the .env settings are read from this file path location
+    """
+
+    env_prefix: ClassVar[str] = "AZURE_OPENAI_"
+
+    chat_deployment_name: str | None = None
+    text_deployment_name: str | None = None
+    embedding_deployment_name: str | None = None
+    text_to_image_deployment_name: str | None = None
+    endpoint: HttpsUrl | None = None
+    base_url: HttpsUrl | None = None
+    api_key: SecretStr | None = None
+    api_version: str = DEFAULT_AZURE_API_VERSION

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/settings/open_ai_settings.py

@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from pydantic import SecretStr
+
+from semantic_kernel.kernel_pydantic import KernelBaseSettings
+
+
+class OpenAISettings(KernelBaseSettings):
+    """OpenAI model settings.
+
+    The settings are first loaded from environment variables with the prefix 'OPENAI_'. 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 'OPENAI_' are:
+    - api_key: SecretStr - OpenAI API key, see https://platform.openai.com/account/api-keys
+        (Env var OPENAI_API_KEY)
+    - org_id: str | None - This is usually optional unless your account belongs to multiple organizations.
+        (Env var OPENAI_ORG_ID)
+    - chat_model_id: str | None - The OpenAI chat model ID to use, for example, gpt-3.5-turbo or gpt-4.
+        (Env var OPENAI_CHAT_MODEL_ID)
+    - text_model_id: str | None - The OpenAI text model ID to use, for example, gpt-3.5-turbo-instruct.
+        (Env var OPENAI_TEXT_MODEL_ID)
+    - embedding_model_id: str | None - The OpenAI embedding model ID to use, for example, text-embedding-ada-002.
+        (Env var OPENAI_EMBEDDING_MODEL_ID)
+    - text_to_image_model_id: str | None - The OpenAI text to image model ID to use, for example, dall-e-3.
+        (Env var OPENAI_TEXT_TO_IMAGE_MODEL_ID)
+    - env_file_path: str | None - if provided, the .env settings are read from this file path location
+    """
+
+    env_prefix: ClassVar[str] = "OPENAI_"
+
+    api_key: SecretStr | None = None
+    org_id: str | None = None
+    chat_model_id: str | None = None
+    text_model_id: str | None = None
+    embedding_model_id: str | None = None
+    text_to_image_model_id: str | None = None