semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/prompt_execution_settings/azure_chat_prompt_execution_settings.py

@@ -0,0 +1,141 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Union
+
+from pydantic import AliasGenerator, ConfigDict, Field
+from pydantic.alias_generators import to_camel, to_snake
+from pydantic.functional_validators import AfterValidator
+
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIChatPromptExecutionSettings,
+)
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.memory.azure_cognitive_search.azure_ai_search_settings import AzureAISearchSettings
+
+logger = logging.getLogger(__name__)
+
+
+class AzureChatRequestBase(KernelBaseModel):
+    """Base class for Azure Chat requests."""
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(validation_alias=to_camel, serialization_alias=to_snake),
+        use_enum_values=True,
+        extra="allow",
+    )
+
+
+class ConnectionStringAuthentication(AzureChatRequestBase):
+    """Connection string authentication."""
+
+    type: Annotated[Literal["ConnectionString", "connection_string"], AfterValidator(to_snake)] = "connection_string"
+    connection_string: str | None = None
+
+
+class ApiKeyAuthentication(AzureChatRequestBase):
+    """API key authentication."""
+
+    type: Annotated[Literal["APIKey", "api_key"], AfterValidator(to_snake)] = "api_key"
+    key: str | None = None
+
+
+class AzureEmbeddingDependency(AzureChatRequestBase):
+    """Azure embedding dependency."""
+
+    type: Annotated[Literal["DeploymentName", "deployment_name"], AfterValidator(to_snake)] = "deployment_name"
+    deployment_name: str | None = None
+
+
+class DataSourceFieldsMapping(AzureChatRequestBase):
+    """Data source fields mapping."""
+
+    title_field: str | None = None
+    url_field: str | None = None
+    filepath_field: str | None = None
+    content_fields: list[str] | None = None
+    vector_fields: list[str] | None = None
+    content_fields_separator: str | None = "\n"
+
+
+class AzureDataSourceParameters(AzureChatRequestBase):
+    """Azure data source parameters."""
+
+    index_name: str
+    index_language: str | None = None
+    fields_mapping: DataSourceFieldsMapping | None = None
+    in_scope: bool | None = True
+    top_n_documents: int | None = 5
+    semantic_configuration: str | None = None
+    role_information: str | None = None
+    filter: str | None = None
+    strictness: int = 3
+    embedding_dependency: AzureEmbeddingDependency | None = None
+
+
+class AzureCosmosDBDataSourceParameters(AzureDataSourceParameters):
+    """Azure Cosmos DB data source parameters."""
+
+    authentication: ConnectionStringAuthentication | None = None
+    database_name: str | None = None
+    container_name: str | None = None
+    embedding_dependency_type: AzureEmbeddingDependency | None = None
+
+
+class AzureCosmosDBDataSource(AzureChatRequestBase):
+    """Azure Cosmos DB data source."""
+
+    type: Literal["azure_cosmos_db"] = "azure_cosmos_db"
+    parameters: AzureCosmosDBDataSourceParameters
+
+
+class AzureAISearchDataSourceParameters(AzureDataSourceParameters):
+    """Azure AI Search data source parameters."""
+
+    endpoint: str | None = None
+    query_type: Annotated[
+        Literal["simple", "semantic", "vector", "vectorSimpleHybrid", "vectorSemanticHybrid"], AfterValidator(to_snake)
+    ] = "simple"
+    authentication: ApiKeyAuthentication | None = None
+
+
+class AzureAISearchDataSource(AzureChatRequestBase):
+    """Azure AI Search data source."""
+
+    type: Literal["azure_search"] = "azure_search"
+    parameters: Annotated[dict, AzureAISearchDataSourceParameters]
+
+    @classmethod
+    def from_azure_ai_search_settings(cls, azure_ai_search_settings: "AzureAISearchSettings", **kwargs: Any):
+        """Create an instance from Azure AI Search settings."""
+        kwargs["parameters"] = {
+            "endpoint": str(azure_ai_search_settings.endpoint),
+            "index_name": azure_ai_search_settings.index_name,
+            "authentication": {
+                "key": azure_ai_search_settings.api_key.get_secret_value() if azure_ai_search_settings.api_key else None
+            },
+        }
+        return cls(**kwargs)
+
+
+DataSource = Annotated[Union[AzureAISearchDataSource, AzureCosmosDBDataSource], Field(discriminator="type")]
+
+
+class ExtraBody(KernelBaseModel):
+    """Extra body for the Azure Chat Completion endpoint."""
+
+    data_sources: list[DataSource] | None = None
+    input_language: str | None = Field(None, serialization_alias="inputLanguage")
+    output_language: str | None = Field(None, serialization_alias="outputLanguage")
+
+    def __getitem__(self, item):
+        """Get an item from the ExtraBody."""
+        return getattr(self, item)
+
+
+class AzureChatPromptExecutionSettings(OpenAIChatPromptExecutionSettings):
+    """Specific settings for the Azure OpenAI Chat Completion endpoint."""
+
+    extra_body: dict[str, Any] | ExtraBody | None = None

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/prompt_execution_settings/open_ai_prompt_execution_settings.py

@@ -0,0 +1,127 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from typing import Any, Literal
+
+if sys.version_info >= (3, 11):
+    from typing import Self  # pragma: no cover
+else:
+    from typing_extensions import Self  # pragma: no cover
+
+from pydantic import Field, field_validator, model_validator
+
+from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.exceptions import ServiceInvalidExecutionSettingsError
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIPromptExecutionSettings(PromptExecutionSettings):
+    """Common request settings for (Azure) OpenAI services."""
+
+    ai_model_id: str | None = Field(None, serialization_alias="model")
+    frequency_penalty: float | None = Field(None, ge=-2.0, le=2.0)
+    logit_bias: dict[str | int, float] | None = None
+    max_tokens: int | None = Field(None, gt=0)
+    number_of_responses: int | None = Field(None, ge=1, le=128, serialization_alias="n")
+    presence_penalty: float | None = Field(None, ge=-2.0, le=2.0)
+    seed: int | None = None
+    stop: str | list[str] | None = None
+    stream: bool = False
+    temperature: float | None = Field(None, ge=0.0, le=2.0)
+    top_p: float | None = Field(None, ge=0.0, le=1.0)
+    user: str | None = None
+
+
+class OpenAITextPromptExecutionSettings(OpenAIPromptExecutionSettings):
+    """Specific settings for the completions endpoint."""
+
+    prompt: str | None = None
+    best_of: int | None = Field(None, ge=1)
+    echo: bool = False
+    logprobs: int | None = Field(None, ge=0, le=5)
+    suffix: str | None = None
+
+    @model_validator(mode="after")
+    def check_best_of_and_n(self) -> "OpenAITextPromptExecutionSettings":
+        """Check that the best_of parameter is not greater than the number_of_responses parameter."""
+        best_of = self.best_of or self.extension_data.get("best_of")
+        number_of_responses = self.number_of_responses or self.extension_data.get("number_of_responses")
+
+        if best_of is not None and number_of_responses is not None and best_of < number_of_responses:
+            raise ServiceInvalidExecutionSettingsError(
+                "When used with number_of_responses, best_of controls the number of candidate completions and n specifies how many to return, therefore best_of must be greater than number_of_responses."  # noqa: E501
+            )
+
+        return self
+
+
+class OpenAIChatPromptExecutionSettings(OpenAIPromptExecutionSettings):
+    """Specific settings for the Chat Completion endpoint."""
+
+    response_format: dict[Literal["type"], Literal["text", "json_object"]] | None = None
+    function_call: str | None = None
+    functions: list[dict[str, Any]] | None = None
+    messages: list[dict[str, Any]] | None = None
+    function_call_behavior: FunctionCallBehavior | None = Field(None, exclude=True)
+    tools: list[dict[str, Any]] | None = Field(
+        None,
+        max_length=64,
+        description="Do not set this manually. It is set by the service based on the function choice configuration.",
+    )
+    tool_choice: str | None = Field(
+        None,
+        description="Do not set this manually. It is set by the service based on the function choice configuration.",
+    )
+
+    @field_validator("functions", "function_call", mode="after")
+    @classmethod
+    def validate_function_call(cls, v: str | list[dict[str, Any]] | None = None):
+        """Validate the function_call and functions parameters."""
+        if v is not None:
+            logger.warning(
+                "The function_call and functions parameters are deprecated. Please use the tool_choice and tools parameters instead."  # noqa: E501
+            )
+        return v
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_function_calling_behaviors(cls, data) -> Any:
+        """Check if function_call_behavior is set and if so, move to use function_choice_behavior instead."""
+        # In an attempt to phase out the use of `function_call_behavior` in favor of `function_choice_behavior`,
+        # we are syncing the `function_call_behavior` with `function_choice_behavior` if the former is set.
+        # This allows us to make decisions off of `function_choice_behavior`. Anytime the `function_call_behavior`
+        # is updated, this validation will run to ensure the `function_choice_behavior` stays in sync.
+        from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+
+        if isinstance(data, dict) and "function_call_behavior" in data.get("extension_data", {}):
+            data["function_choice_behavior"] = FunctionChoiceBehavior.from_function_call_behavior(
+                data.get("extension_data", {}).get("function_call_behavior")
+            )
+        return data
+
+    @field_validator("function_call_behavior", mode="after")
+    @classmethod
+    def check_for_function_call_behavior(cls, v) -> Self:
+        """Check if function_choice_behavior is set, if not, set it to default."""
+        if v is not None:
+            logger.warning(
+                "The `function_call_behavior` parameter is deprecated. Please use the `function_choice_behavior` parameter instead."  # noqa: E501
+            )
+        return v
+
+
+class OpenAIEmbeddingPromptExecutionSettings(PromptExecutionSettings):
+    """Specific settings for the text embedding endpoint."""
+
+    input: str | list[str] | list[int] | list[list[int]] | None = None
+    ai_model_id: str | None = Field(None, serialization_alias="model")
+    encoding_format: Literal["float", "base64"] | None = None
+    user: str | None = None
+    extra_headers: dict | None = None
+    extra_query: dict | None = None
+    extra_body: dict | None = None
+    timeout: float | None = None
+    dimensions: int | None = Field(None, gt=0, le=3072)

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

@@ -0,0 +1,210 @@
+# Copyright (c) Microsoft. All rights reserved.
+import json
+import logging
+from collections.abc import Mapping
+from copy import deepcopy
+from typing import Any, TypeVar
+from uuid import uuid4
+
+from openai import AsyncAzureOpenAI
+from openai.lib.azure import AsyncAzureADTokenProvider
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
+    AzureChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.azure_config_base import AzureOpenAIConfigBase
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_chat_completion_base import OpenAIChatCompletionBase
+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.azure_open_ai_settings import AzureOpenAISettings
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.contents.function_call_content import FunctionCallContent
+from semantic_kernel.contents.function_result_content import FunctionResultContent
+from semantic_kernel.contents.streaming_chat_message_content import StreamingChatMessageContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.contents.utils.finish_reason import FinishReason
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+TChatMessageContent = TypeVar("TChatMessageContent", ChatMessageContent, StreamingChatMessageContent)
+
+
+class AzureChatCompletion(AzureOpenAIConfigBase, OpenAIChatCompletionBase, OpenAITextCompletionBase):
+    """Azure Chat completion class."""
+
+    def __init__(
+        self,
+        service_id: str | None = None,
+        api_key: str | None = None,
+        deployment_name: str | None = None,
+        endpoint: str | None = None,
+        base_url: str | None = None,
+        api_version: str | None = None,
+        ad_token: str | None = None,
+        ad_token_provider: AsyncAzureADTokenProvider | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        async_client: AsyncAzureOpenAI | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an AzureChatCompletion service.
+
+        Args:
+            service_id (str | None): The service ID for the Azure deployment. (Optional)
+            api_key  (str | None): The optional api key. If provided, will override the value in the
+                env vars or .env file.
+            deployment_name  (str | None): The optional deployment. If provided, will override the value
+                (chat_deployment_name) in the env vars or .env file.
+            endpoint (str | None): The optional deployment endpoint. If provided will override the value
+                in the env vars or .env file.
+            base_url (str | None): The optional deployment base_url. If provided will override the value
+                in the env vars or .env file.
+            api_version (str | None): The optional deployment api version. If provided will override the value
+                in the env vars or .env file.
+            ad_token (str | None): The Azure Active Directory token. (Optional)
+            ad_token_provider (AsyncAzureADTokenProvider): The Azure Active Directory token provider. (Optional)
+            default_headers (Mapping[str, str]): The default headers mapping of string keys to
+                string values for HTTP requests. (Optional)
+            async_client (AsyncAzureOpenAI | None): An existing client to use. (Optional)
+            env_file_path (str | None): Use the environment settings file as a fallback to using env vars.
+            env_file_encoding (str | None): The encoding of the environment settings file, defaults to 'utf-8'.
+        """
+        try:
+            azure_openai_settings = AzureOpenAISettings.create(
+                api_key=api_key,
+                base_url=base_url,
+                endpoint=endpoint,
+                chat_deployment_name=deployment_name,
+                api_version=api_version,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as exc:
+            raise ServiceInitializationError(f"Failed to validate settings: {exc}") from exc
+
+        if not azure_openai_settings.chat_deployment_name:
+            raise ServiceInitializationError("chat_deployment_name is required.")
+
+        if not azure_openai_settings.api_key and not ad_token and not ad_token_provider:
+            raise ServiceInitializationError("Please provide either api_key, ad_token or ad_token_provider")
+
+        super().__init__(
+            deployment_name=azure_openai_settings.chat_deployment_name,
+            endpoint=azure_openai_settings.endpoint,
+            base_url=azure_openai_settings.base_url,
+            api_version=azure_openai_settings.api_version,
+            service_id=service_id,
+            api_key=azure_openai_settings.api_key.get_secret_value() if azure_openai_settings.api_key else None,
+            ad_token=ad_token,
+            ad_token_provider=ad_token_provider,
+            default_headers=default_headers,
+            ai_model_type=OpenAIModelTypes.CHAT,
+            client=async_client,
+        )
+
+    @classmethod
+    def from_dict(cls, settings: dict[str, Any]) -> "AzureChatCompletion":
+        """Initialize an Azure OpenAI service from a dictionary of settings.
+
+        Args:
+            settings: A dictionary of settings for the service.
+                should contain keys: service_id, and optionally:
+                    ad_auth, ad_token_provider, default_headers
+        """
+        return AzureChatCompletion(
+            service_id=settings.get("service_id"),
+            api_key=settings.get("api_key"),
+            deployment_name=settings.get("deployment_name"),
+            endpoint=settings.get("endpoint"),
+            base_url=settings.get("base_url"),
+            api_version=settings.get("api_version"),
+            ad_token=settings.get("ad_token"),
+            ad_token_provider=settings.get("ad_token_provider"),
+            default_headers=settings.get("default_headers"),
+            env_file_path=settings.get("env_file_path"),
+        )
+
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        """Create a request settings object."""
+        return AzureChatPromptExecutionSettings
+
+    def _create_chat_message_content(
+        self, response: ChatCompletion, choice: Choice, response_metadata: dict[str, Any]
+    ) -> ChatMessageContent:
+        """Create an Azure chat message content object from a choice."""
+        content = super()._create_chat_message_content(response, choice, response_metadata)
+        return self._add_tool_message_to_chat_message_content(content, choice)
+
+    def _create_streaming_chat_message_content(
+        self,
+        chunk: ChatCompletionChunk,
+        choice: ChunkChoice,
+        chunk_metadata: dict[str, Any],
+    ) -> "StreamingChatMessageContent":
+        """Create an Azure streaming chat message content object from a choice."""
+        content = super()._create_streaming_chat_message_content(chunk, choice, chunk_metadata)
+        assert isinstance(content, StreamingChatMessageContent) and isinstance(choice, ChunkChoice)  # nosec
+        return self._add_tool_message_to_chat_message_content(content, choice)
+
+    def _add_tool_message_to_chat_message_content(
+        self,
+        content: TChatMessageContent,
+        choice: Choice | ChunkChoice,
+    ) -> TChatMessageContent:
+        if tool_message := self._get_tool_message_from_chat_choice(choice=choice):
+            if not isinstance(tool_message, dict):
+                # try to json, to ensure it is a dictionary
+                try:
+                    tool_message = json.loads(tool_message)
+                except json.JSONDecodeError:
+                    logger.warning("Tool message is not a dictionary, ignore context.")
+                    return content
+            function_call = FunctionCallContent(
+                id=str(uuid4()),
+                name="Azure-OnYourData",
+                arguments=json.dumps({"query": tool_message.get("intent", [])}),
+            )
+            result = FunctionResultContent.from_function_call_content_and_result(
+                result=tool_message["citations"], function_call_content=function_call
+            )
+            content.items.insert(0, function_call)
+            content.items.insert(1, result)
+        return content
+
+    def _get_tool_message_from_chat_choice(self, choice: Choice | ChunkChoice) -> dict[str, Any] | None:
+        """Get the tool message from a choice."""
+        content = choice.message if isinstance(choice, Choice) else choice.delta
+        # When you enable asynchronous content filtering in Azure OpenAI, you may receive empty deltas
+        if content and content.model_extra is not None:
+            return content.model_extra.get("context", None)
+        # openai allows extra content, so model_extra will be a dict, but we need to check anyway, but no way to test.
+        return None  # pragma: no cover
+
+    @staticmethod
+    def split_message(message: "ChatMessageContent") -> list["ChatMessageContent"]:
+        """Split an Azure On Your Data response into separate ChatMessageContents.
+
+        If the message does not have three contents, and those three are one each of:
+        FunctionCallContent, FunctionResultContent, and TextContent,
+        it will not return three messages, potentially only one or two.
+
+        The order of the returned messages is as expected by OpenAI.
+        """
+        if len(message.items) != 3:
+            return [message]
+        messages = {"tool_call": deepcopy(message), "tool_result": deepcopy(message), "assistant": deepcopy(message)}
+        for key, msg in messages.items():
+            if key == "tool_call":
+                msg.items = [item for item in msg.items if isinstance(item, FunctionCallContent)]
+                msg.finish_reason = FinishReason.FUNCTION_CALL
+            if key == "tool_result":
+                msg.items = [item for item in msg.items if isinstance(item, FunctionResultContent)]
+            if key == "assistant":
+                msg.items = [item for item in msg.items if isinstance(item, TextContent)]
+        return [messages["tool_call"], messages["tool_result"], messages["assistant"]]

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

@@ -0,0 +1,115 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Awaitable, Callable, Mapping
+from copy import copy
+
+from openai import AsyncAzureOpenAI
+from pydantic import ConfigDict, validate_call
+
+from semantic_kernel.connectors.ai.open_ai.const import DEFAULT_AZURE_API_VERSION
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_handler import OpenAIHandler, OpenAIModelTypes
+from semantic_kernel.const import USER_AGENT
+from semantic_kernel.exceptions import ServiceInitializationError
+from semantic_kernel.kernel_pydantic import HttpsUrl
+from semantic_kernel.utils.telemetry.user_agent import APP_INFO, prepend_semantic_kernel_to_user_agent
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class AzureOpenAIConfigBase(OpenAIHandler):
+    """Internal class for configuring a connection to an Azure OpenAI service."""
+
+    @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+    def __init__(
+        self,
+        deployment_name: str,
+        ai_model_type: OpenAIModelTypes,
+        endpoint: HttpsUrl | None = None,
+        base_url: HttpsUrl | None = None,
+        api_version: str = DEFAULT_AZURE_API_VERSION,
+        service_id: str | None = None,
+        api_key: str | None = None,
+        ad_token: str | None = None,
+        ad_token_provider: Callable[[], str | Awaitable[str]] | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        client: AsyncAzureOpenAI | None = None,
+    ) -> None:
+        """Internal class for configuring a connection to an Azure OpenAI service.
+
+        The `validate_call` decorator is used with a configuration that allows arbitrary types.
+        This is necessary for types like `HttpsUrl` and `OpenAIModelTypes`.
+
+        Args:
+            deployment_name (str): Name of the deployment.
+            ai_model_type (OpenAIModelTypes): The type of OpenAI model to deploy.
+            endpoint (HttpsUrl): The specific endpoint URL for the deployment. (Optional)
+            base_url (HttpsUrl): The base URL for Azure services. (Optional)
+            api_version (str): Azure API version. Defaults to the defined DEFAULT_AZURE_API_VERSION.
+            service_id (str): Service ID for the deployment. (Optional)
+            api_key (str): API key for Azure services. (Optional)
+            ad_token (str): Azure AD token for authentication. (Optional)
+            ad_token_provider (Callable[[], Union[str, Awaitable[str]]]): A callable
+                or coroutine function providing Azure AD tokens. (Optional)
+            default_headers (Union[Mapping[str, str], None]): Default headers for HTTP requests. (Optional)
+            client (AsyncAzureOpenAI): An existing client to use. (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 and not ad_token and not ad_token_provider:
+                raise ServiceInitializationError(
+                    "Please provide either api_key, ad_token or ad_token_provider or a client."
+                )
+            if not base_url:
+                if not endpoint:
+                    raise ServiceInitializationError("Please provide an endpoint or a base_url")
+                base_url = HttpsUrl(f"{str(endpoint).rstrip('/')}/openai/deployments/{deployment_name}")
+            client = AsyncAzureOpenAI(
+                base_url=str(base_url),
+                api_version=api_version,
+                api_key=api_key,
+                azure_ad_token=ad_token,
+                azure_ad_token_provider=ad_token_provider,
+                default_headers=merged_headers,
+            )
+        args = {
+            "ai_model_id": deployment_name,
+            "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]:
+        """Convert the configuration to a dictionary."""
+        client_settings = {
+            "base_url": str(self.client.base_url),
+            "api_version": self.client._custom_query["api-version"],
+            "api_key": self.client.api_key,
+            "ad_token": getattr(self.client, "_azure_ad_token", None),
+            "ad_token_provider": getattr(self.client, "_azure_ad_token_provider", None),
+            "default_headers": {k: v for k, v in self.client.default_headers.items() if k != USER_AGENT},
+        }
+        base = self.model_dump(
+            exclude={
+                "prompt_tokens",
+                "completion_tokens",
+                "total_tokens",
+                "api_type",
+                "org_id",
+                "ai_model_type",
+                "service_id",
+                "client",
+            },
+            by_alias=True,
+            exclude_none=True,
+        )
+        base.update(client_settings)
+        return base