semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/ollama/services/ollama_chat_completion.py

@@ -0,0 +1,253 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from collections.abc import AsyncGenerator, AsyncIterator, Mapping
+from typing import TYPE_CHECKING, Any
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from ollama import AsyncClient, Message
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
+from semantic_kernel.connectors.ai.ollama.ollama_prompt_execution_settings import OllamaChatPromptExecutionSettings
+from semantic_kernel.connectors.ai.ollama.ollama_settings import OllamaSettings
+from semantic_kernel.connectors.ai.ollama.services.ollama_base import OllamaBase
+from semantic_kernel.connectors.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.contents import AuthorRole
+from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+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.exceptions.service_exceptions import ServiceInitializationError, ServiceInvalidResponseError
+from semantic_kernel.utils.telemetry.model_diagnostics.decorators import trace_chat_completion, trace_text_completion
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OllamaChatCompletion(OllamaBase, TextCompletionClientBase, ChatCompletionClientBase):
+    """Initializes a new instance of the OllamaChatCompletion class.
+
+    Make sure to have the ollama service running either locally or remotely.
+    """
+
+    def __init__(
+        self,
+        service_id: str | None = None,
+        ai_model_id: str | None = None,
+        host: str | None = None,
+        client: AsyncClient | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an OllamaChatCompletion service.
+
+        Args:
+            service_id (Optional[str]): Service ID tied to the execution settings. (Optional)
+            ai_model_id (Optional[str]): The model name. (Optional)
+            host (Optional[str]): URL of the Ollama server, defaults to None and
+                will use the default Ollama service address: http://127.0.0.1:11434. (Optional)
+            client (Optional[AsyncClient]): A custom Ollama client to use for the service. (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:
+            ollama_settings = OllamaSettings.create(
+                model=ai_model_id,
+                host=host,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create Ollama settings.", ex) from ex
+
+        super().__init__(
+            service_id=service_id or ollama_settings.model,
+            ai_model_id=ollama_settings.model,
+            client=client or AsyncClient(host=ollama_settings.host),
+        )
+
+    @override
+    @trace_chat_completion(OllamaBase.MODEL_PROVIDER_NAME)
+    async def get_chat_message_contents(
+        self,
+        chat_history: ChatHistory,
+        settings: "PromptExecutionSettings",
+        **kwargs: Any,
+    ) -> list[ChatMessageContent]:
+        """This is the method that is called from the kernel to get a response from a chat-optimized LLM.
+
+        Args:
+            chat_history (ChatHistory): A chat history that contains a list of chat messages,
+                that can be rendered into a set of messages, from system, user, assistant and function.
+            settings (PromptExecutionSettings): Settings for the request.
+            kwargs (Dict[str, Any]): The optional arguments.
+
+        Returns:
+            List[ChatMessageContent]: A list of ChatMessageContent objects representing the response(s) from the LLM.
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+        prepared_chat_history = self._prepare_chat_history_for_request(chat_history)
+
+        response_object = await self.client.chat(
+            model=self.ai_model_id,
+            messages=prepared_chat_history,
+            stream=False,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, Mapping):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected Mapping but got {type(response_object)}."
+            )
+
+        return [
+            ChatMessageContent(
+                inner_content=response_object,
+                ai_model_id=self.ai_model_id,
+                role=AuthorRole.ASSISTANT,
+                content=response_object.get("message", {"content": None}).get("content", None),
+            )
+        ]
+
+    async def get_streaming_chat_message_contents(
+        self,
+        chat_history: ChatHistory,
+        settings: "PromptExecutionSettings",
+        **kwargs: Any,
+    ) -> AsyncGenerator[list[StreamingChatMessageContent], Any]:
+        """Streams a text completion using an Ollama model.
+
+        Note that this method does not support multiple responses.
+
+        Args:
+            chat_history (ChatHistory): A chat history that contains a list of chat messages,
+                that can be rendered into a set of messages, from system, user, assistant and function.
+            settings (PromptExecutionSettings): Request settings.
+            kwargs (Dict[str, Any]): The optional arguments.
+
+        Yields:
+            List[StreamingChatMessageContent]: Stream of StreamingChatMessageContent objects.
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+        prepared_chat_history = self._prepare_chat_history_for_request(chat_history)
+
+        response_object = await self.client.chat(
+            model=self.ai_model_id,
+            messages=prepared_chat_history,
+            stream=True,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, AsyncIterator):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected AsyncIterator but got {type(response_object)}."
+            )
+
+        async for part in response_object:
+            yield [
+                StreamingChatMessageContent(
+                    role=AuthorRole.ASSISTANT,
+                    choice_index=0,
+                    inner_content=part,
+                    ai_model_id=self.ai_model_id,
+                    content=part.get("message", {"content": None}).get("content", None),
+                )
+            ]
+
+    @override
+    @trace_text_completion(OllamaBase.MODEL_PROVIDER_NAME)
+    async def get_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> list[TextContent]:
+        """This is the method that is called from the kernel to get a response from a text-optimized LLM.
+
+        Args:
+            prompt (str): A prompt to complete
+            settings (PromptExecutionSettings): Settings for the request.
+
+        Returns:
+            List["TextContent"]: The completion result(s).
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+        prepared_chat_history = [Message(role=AuthorRole.USER.value, content=prompt)]
+
+        response_object = await self.client.chat(
+            model=self.ai_model_id,
+            messages=prepared_chat_history,
+            stream=False,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, Mapping):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected Mapping but got {type(response_object)}."
+            )
+
+        return [
+            TextContent(
+                inner_content=response_object,
+                ai_model_id=self.ai_model_id,
+                text=response_object.get("message", {"content": None}).get("content", None),
+            )
+        ]
+
+    async def get_streaming_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> AsyncGenerator[list[StreamingTextContent], Any]:
+        """Streams a text completion using an Ollama model.
+
+        Note that this method does not support multiple responses.
+
+        Args:
+            prompt (str): A chat history that contains the prompt to complete.
+            settings (PromptExecutionSettings): Request settings.
+
+        Yields:
+            List["StreamingTextContent"]: The result stream made up of StreamingTextContent objects.
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+        prepared_chat_history = [Message(role=AuthorRole.USER.value, content=prompt)]
+
+        response_object = await self.client.chat(
+            model=self.ai_model_id,
+            messages=prepared_chat_history,
+            stream=True,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, AsyncIterator):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected AsyncIterator but got {type(response_object)}."
+            )
+
+        async for part in response_object:
+            yield [
+                StreamingTextContent(
+                    choice_index=0,
+                    inner_content=part,
+                    ai_model_id=self.ai_model_id,
+                    text=part.get("message", {"content": None}).get("content", None),
+                )
+            ]
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        """Get the request settings class."""
+        return OllamaChatPromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/ollama/services/ollama_text_completion.py

@@ -0,0 +1,150 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from collections.abc import AsyncGenerator, AsyncIterator, Mapping
+from typing import TYPE_CHECKING, Any
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from ollama import AsyncClient
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.ollama.ollama_prompt_execution_settings import OllamaTextPromptExecutionSettings
+from semantic_kernel.connectors.ai.ollama.ollama_settings import OllamaSettings
+from semantic_kernel.connectors.ai.ollama.services.ollama_base import OllamaBase
+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.exceptions.service_exceptions import ServiceInitializationError, ServiceInvalidResponseError
+from semantic_kernel.utils.telemetry.model_diagnostics.decorators import trace_text_completion
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class OllamaTextCompletion(OllamaBase, TextCompletionClientBase):
+    """Initializes a new instance of the OllamaTextCompletion class.
+
+    Make sure to have the ollama service running either locally or remotely.
+    """
+
+    def __init__(
+        self,
+        service_id: str | None = None,
+        ai_model_id: str | None = None,
+        host: str | None = None,
+        client: AsyncClient | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an OllamaChatCompletion service.
+
+        Args:
+            service_id (Optional[str]): Service ID tied to the execution settings. (Optional)
+            ai_model_id (Optional[str]): The model name. (Optional)
+            host (Optional[str]): URL of the Ollama server, defaults to None and
+                will use the default Ollama service address: http://127.0.0.1:11434. (Optional)
+            client (Optional[AsyncClient]): A custom Ollama client to use for the service. (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:
+            ollama_settings = OllamaSettings.create(
+                model=ai_model_id,
+                host=host,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create Ollama settings.", ex) from ex
+
+        super().__init__(
+            service_id=service_id or ollama_settings.model,
+            ai_model_id=ollama_settings.model,
+            client=client or AsyncClient(host=ollama_settings.host),
+        )
+
+    @override
+    @trace_text_completion(OllamaBase.MODEL_PROVIDER_NAME)
+    async def get_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> list[TextContent]:
+        """This is the method that is called from the kernel to get a response from a text-optimized LLM.
+
+        Args:
+            prompt (str): The prompt to send to the LLM.
+            settings (OllamaTextPromptExecutionSettings): Settings for the request.
+
+        Returns:
+            List[TextContent]: A list of TextContent objects representing the response(s) from the LLM.
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+
+        response_object = await self.client.generate(
+            model=self.ai_model_id,
+            prompt=prompt,
+            stream=False,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, Mapping):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected Mapping but got {type(response_object)}."
+            )
+
+        inner_content = response_object
+        text = inner_content["response"]
+        return [TextContent(inner_content=inner_content, ai_model_id=self.ai_model_id, text=text)]
+
+    async def get_streaming_text_contents(
+        self,
+        prompt: str,
+        settings: "PromptExecutionSettings",
+    ) -> AsyncGenerator[list[StreamingTextContent], Any]:
+        """Streams a text completion using an Ollama model.
+
+        Note that this method does not support multiple responses,
+        but the result will be a list anyway.
+
+        Args:
+            prompt (str): Prompt to complete.
+            settings (OllamaTextPromptExecutionSettings): Request settings.
+
+        Yields:
+            List[StreamingTextContent]: Completion result.
+        """
+        settings = self.get_prompt_execution_settings_from_settings(settings)
+
+        response_object = await self.client.generate(
+            model=self.ai_model_id,
+            prompt=prompt,
+            stream=True,
+            **settings.prepare_settings_dict(),
+        )
+
+        if not isinstance(response_object, AsyncIterator):
+            raise ServiceInvalidResponseError(
+                "Invalid response type from Ollama chat completion. "
+                f"Expected AsyncIterator but got {type(response_object)}."
+            )
+
+        async for part in response_object:
+            yield [
+                StreamingTextContent(
+                    choice_index=0, inner_content=part, ai_model_id=self.ai_model_id, text=part.get("response")
+                )
+            ]
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        """Get the request settings class."""
+        return OllamaTextPromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/ollama/services/ollama_text_embedding.py

@@ -0,0 +1,109 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from typing import TYPE_CHECKING, Any
+
+from ollama import AsyncClient
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.ollama.ollama_prompt_execution_settings import OllamaEmbeddingPromptExecutionSettings
+from semantic_kernel.connectors.ai.ollama.ollama_settings import OllamaSettings
+from semantic_kernel.connectors.ai.ollama.services.ollama_base import OllamaBase
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from numpy import array, ndarray
+
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import EmbeddingGeneratorBase
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_class
+class OllamaTextEmbedding(OllamaBase, EmbeddingGeneratorBase):
+    """Ollama embeddings client.
+
+    Make sure to have the ollama service running either locally or remotely.
+    """
+
+    def __init__(
+        self,
+        service_id: str | None = None,
+        ai_model_id: str | None = None,
+        host: str | None = None,
+        client: AsyncClient | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an OllamaChatCompletion service.
+
+        Args:
+            service_id (Optional[str]): Service ID tied to the execution settings. (Optional)
+            ai_model_id (Optional[str]): The model name. (Optional)
+            host (Optional[str]): URL of the Ollama server, defaults to None and
+                will use the default Ollama service address: http://127.0.0.1:11434. (Optional)
+            client (Optional[AsyncClient]): A custom Ollama client to use for the service. (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:
+            ollama_settings = OllamaSettings.create(
+                model=ai_model_id,
+                host=host,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as ex:
+            raise ServiceInitializationError("Failed to create Ollama settings.", ex) from ex
+
+        super().__init__(
+            service_id=service_id or ollama_settings.model,
+            ai_model_id=ollama_settings.model,
+            client=client or AsyncClient(host=ollama_settings.host),
+        )
+
+    @override
+    async def generate_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> ndarray:
+        raw_embeddings = await self.generate_raw_embeddings(texts, settings, **kwargs)
+        return array(raw_embeddings)
+
+    @override
+    async def generate_raw_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> Any:
+        if not settings:
+            settings = OllamaEmbeddingPromptExecutionSettings()
+        else:
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+
+        result = []
+        for text in texts:
+            response_object = await self.client.embeddings(
+                model=self.ai_model_id,
+                prompt=text,
+                **settings.prepare_settings_dict(),
+            )
+            result.append(response_object["embedding"])
+
+        return result
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        return OllamaEmbeddingPromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/__init__.py

@@ -0,0 +1,56 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
+    ApiKeyAuthentication,
+    AzureAISearchDataSource,
+    AzureAISearchDataSourceParameters,
+    AzureChatPromptExecutionSettings,
+    AzureCosmosDBDataSource,
+    AzureCosmosDBDataSourceParameters,
+    AzureDataSourceParameters,
+    AzureEmbeddingDependency,
+    ConnectionStringAuthentication,
+    DataSourceFieldsMapping,
+    ExtraBody,
+)
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.open_ai_prompt_execution_settings import (
+    OpenAIChatPromptExecutionSettings,
+    OpenAIEmbeddingPromptExecutionSettings,
+    OpenAIPromptExecutionSettings,
+    OpenAITextPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.open_ai.services.azure_chat_completion import AzureChatCompletion
+from semantic_kernel.connectors.ai.open_ai.services.azure_text_completion import AzureTextCompletion
+from semantic_kernel.connectors.ai.open_ai.services.azure_text_embedding import AzureTextEmbedding
+from semantic_kernel.connectors.ai.open_ai.services.azure_text_to_image import AzureTextToImage
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_chat_completion import OpenAIChatCompletion
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_completion import OpenAITextCompletion
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_embedding import OpenAITextEmbedding
+from semantic_kernel.connectors.ai.open_ai.services.open_ai_text_to_image import OpenAITextToImage
+
+__all__ = [
+    "ApiKeyAuthentication",
+    "AzureAISearchDataSource",
+    "AzureAISearchDataSourceParameters",
+    "AzureChatCompletion",
+    "AzureChatPromptExecutionSettings",
+    "AzureCosmosDBDataSource",
+    "AzureCosmosDBDataSourceParameters",
+    "AzureDataSourceParameters",
+    "AzureEmbeddingDependency",
+    "AzureTextCompletion",
+    "AzureTextEmbedding",
+    "AzureTextToImage",
+    "ConnectionStringAuthentication",
+    "DataSourceFieldsMapping",
+    "DataSourceFieldsMapping",
+    "ExtraBody",
+    "OpenAIChatCompletion",
+    "OpenAIChatPromptExecutionSettings",
+    "OpenAIEmbeddingPromptExecutionSettings",
+    "OpenAIPromptExecutionSettings",
+    "OpenAITextCompletion",
+    "OpenAITextEmbedding",
+    "OpenAITextPromptExecutionSettings",
+    "OpenAITextToImage",
+]

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/const.py

@@ -0,0 +1,5 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Final
+
+DEFAULT_AZURE_API_VERSION: Final[str] = "2024-02-01"

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/open_ai/exceptions/content_filter_ai_exception.py

@@ -0,0 +1,89 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from openai import BadRequestError
+
+from semantic_kernel.exceptions import ServiceContentFilterException
+
+
+class ContentFilterResultSeverity(Enum):
+    """The severity of the content filter result."""
+
+    HIGH = "high"
+    MEDIUM = "medium"
+    SAFE = "safe"
+
+
+@dataclass
+class ContentFilterResult:
+    """The result of a content filter check."""
+
+    filtered: bool = False
+    detected: bool = False
+    severity: ContentFilterResultSeverity = ContentFilterResultSeverity.SAFE
+
+    @classmethod
+    def from_inner_error_result(cls, inner_error_results: dict[str, Any]) -> "ContentFilterResult":
+        """Creates a ContentFilterResult from the inner error results.
+
+        Args:
+            key (str): The key to get the inner error result from.
+            inner_error_results (Dict[str, Any]): The inner error results.
+
+        Returns:
+            ContentFilterResult: The ContentFilterResult.
+        """
+        return cls(
+            filtered=inner_error_results.get("filtered", False),
+            detected=inner_error_results.get("detected", False),
+            severity=ContentFilterResultSeverity(
+                inner_error_results.get("severity", ContentFilterResultSeverity.SAFE.value)
+            ),
+        )
+
+
+class ContentFilterCodes(Enum):
+    """Content filter codes."""
+
+    RESPONSIBLE_AI_POLICY_VIOLATION = "ResponsibleAIPolicyViolation"
+
+
+@dataclass
+class ContentFilterAIException(ServiceContentFilterException):
+    """AI exception for an error from Azure OpenAI's content filter."""
+
+    # The parameter that caused the error.
+    param: str | None
+
+    # The error code specific to the content filter.
+    content_filter_code: ContentFilterCodes
+
+    # The results of the different content filter checks.
+    content_filter_result: dict[str, ContentFilterResult]
+
+    def __init__(
+        self,
+        message: str,
+        inner_exception: BadRequestError,
+    ) -> None:
+        """Initializes a new instance of the ContentFilterAIException class.
+
+        Args:
+            message (str): The error message.
+            inner_exception (Exception): The inner exception.
+        """
+        super().__init__(message)
+
+        self.param = inner_exception.param
+        if inner_exception.body is not None and isinstance(inner_exception.body, dict):
+            inner_error = inner_exception.body.get("innererror", {})
+            self.content_filter_code = ContentFilterCodes(
+                inner_error.get("code", ContentFilterCodes.RESPONSIBLE_AI_POLICY_VIOLATION.value)
+            )
+            self.content_filter_result = {
+                key: ContentFilterResult.from_inner_error_result(values)
+                for key, values in inner_error.get("content_filter_result", {}).items()
+            }