semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/anthropic/services/anthropic_chat_completion.py

@@ -0,0 +1,255 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from collections.abc import AsyncGenerator
+from typing import 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 anthropic import AsyncAnthropic
+from anthropic.types import (
+    ContentBlockStopEvent,
+    Message,
+    RawContentBlockDeltaEvent,
+    RawMessageDeltaEvent,
+    RawMessageStartEvent,
+    TextBlock,
+)
+from pydantic import ValidationError
+
+from semantic_kernel.connectors.ai.anthropic.prompt_execution_settings.anthropic_prompt_execution_settings import (
+    AnthropicChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.anthropic.settings.anthropic_settings import AnthropicSettings
+from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.contents.chat_message_content import ITEM_TYPES, ChatMessageContent
+from semantic_kernel.contents.streaming_chat_message_content import ITEM_TYPES as STREAMING_ITEM_TYPES
+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 as SemanticKernelFinishReason
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError, ServiceResponseException
+from semantic_kernel.utils.experimental_decorator import experimental_class
+from semantic_kernel.utils.telemetry.model_diagnostics.decorators import trace_chat_completion
+
+# map finish reasons from Anthropic to Semantic Kernel
+ANTHROPIC_TO_SEMANTIC_KERNEL_FINISH_REASON_MAP = {
+    "end_turn": SemanticKernelFinishReason.STOP,
+    "max_tokens": SemanticKernelFinishReason.LENGTH,
+    "tool_use": SemanticKernelFinishReason.TOOL_CALLS,
+}
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_class
+class AnthropicChatCompletion(ChatCompletionClientBase):
+    """Antropic ChatCompletion class."""
+
+    MODEL_PROVIDER_NAME: ClassVar[str] = "anthropic"
+
+    async_client: AsyncAnthropic
+
+    def __init__(
+        self,
+        ai_model_id: str | None = None,
+        service_id: str | None = None,
+        api_key: str | None = None,
+        async_client: AsyncAnthropic | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize an AnthropicChatCompletion service.
+
+        Args:
+            ai_model_id: Anthropic model name, see
+                https://docs.anthropic.com/en/docs/about-claude/models#model-names
+            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.
+            async_client: An existing client to use.
+            env_file_path: Use the environment settings file as a fallback
+                to environment variables.
+            env_file_encoding: The encoding of the environment settings file.
+        """
+        try:
+            anthropic_settings = AnthropicSettings.create(
+                api_key=api_key,
+                chat_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 Anthropic settings.", ex) from ex
+
+        if not anthropic_settings.chat_model_id:
+            raise ServiceInitializationError("The Anthropic chat model ID is required.")
+
+        if not async_client:
+            async_client = AsyncAnthropic(
+                api_key=anthropic_settings.api_key.get_secret_value(),
+            )
+
+        super().__init__(
+            async_client=async_client,
+            service_id=service_id or anthropic_settings.chat_model_id,
+            ai_model_id=anthropic_settings.chat_model_id,
+        )
+
+    @override
+    @trace_chat_completion(MODEL_PROVIDER_NAME)
+    async def get_chat_message_contents(
+        self,
+        chat_history: "ChatHistory",
+        settings: "PromptExecutionSettings",
+        **kwargs: Any,
+    ) -> list["ChatMessageContent"]:
+        """Executes a chat completion request and returns the result.
+
+        Args:
+            chat_history: The chat history to use for the chat completion.
+            settings: The settings to use for the chat completion request.
+            kwargs: The optional arguments.
+
+        Returns:
+            The completion result(s).
+        """
+        if not isinstance(settings, AnthropicChatPromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, AnthropicChatPromptExecutionSettings)  # nosec
+
+        if not settings.ai_model_id:
+            settings.ai_model_id = self.ai_model_id
+
+        settings.messages = self._prepare_chat_history_for_request(chat_history)
+        try:
+            response = await self.async_client.messages.create(**settings.prepare_settings_dict())
+        except Exception as ex:
+            raise ServiceResponseException(
+                f"{type(self)} service failed to complete the prompt",
+                ex,
+            ) from ex
+
+        metadata: dict[str, Any] = {"id": response.id}
+        # Check if usage exists and has a value, then add it to the metadata
+        if hasattr(response, "usage") and response.usage is not None:
+            metadata["usage"] = response.usage
+
+        return [
+            self._create_chat_message_content(response, content_block, metadata) for content_block in response.content
+        ]
+
+    async def get_streaming_chat_message_contents(
+        self,
+        chat_history: ChatHistory,
+        settings: PromptExecutionSettings,
+        **kwargs: Any,
+    ) -> AsyncGenerator[list[StreamingChatMessageContent], Any]:
+        """Executes a streaming chat completion request and returns the result.
+
+        Args:
+            chat_history: The chat history to use for the chat completion.
+            settings: The settings to use for the chat completion request.
+            kwargs: The optional arguments.
+
+        Yields:
+            A stream of StreamingChatMessageContent.
+        """
+        if not isinstance(settings, AnthropicChatPromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, AnthropicChatPromptExecutionSettings)  # nosec
+
+        if not settings.ai_model_id:
+            settings.ai_model_id = self.ai_model_id
+
+        settings.messages = self._prepare_chat_history_for_request(chat_history)
+        try:
+            async with self.async_client.messages.stream(**settings.prepare_settings_dict()) as stream:
+                author_role = None
+                metadata: dict[str, Any] = {"usage": {}, "id": None}
+                content_block_idx = 0
+
+                async for stream_event in stream:
+                    if isinstance(stream_event, RawMessageStartEvent):
+                        author_role = stream_event.message.role
+                        metadata["usage"]["input_tokens"] = stream_event.message.usage.input_tokens
+                        metadata["id"] = stream_event.message.id
+                    elif isinstance(stream_event, (RawContentBlockDeltaEvent, RawMessageDeltaEvent)):
+                        yield [
+                            self._create_streaming_chat_message_content(
+                                stream_event, content_block_idx, author_role, metadata
+                            )
+                        ]
+                    elif isinstance(stream_event, ContentBlockStopEvent):
+                        content_block_idx += 1
+
+        except Exception as ex:
+            raise ServiceResponseException(
+                f"{type(self)} service failed to complete the request",
+                ex,
+            ) from ex
+
+    def _create_chat_message_content(
+        self, response: Message, content: TextBlock, response_metadata: dict[str, Any]
+    ) -> "ChatMessageContent":
+        """Create a chat message content object."""
+        items: list[ITEM_TYPES] = []
+
+        if content.text:
+            items.append(TextContent(text=content.text))
+
+        finish_reason = None
+        if response.stop_reason:
+            finish_reason = ANTHROPIC_TO_SEMANTIC_KERNEL_FINISH_REASON_MAP[response.stop_reason]
+
+        return ChatMessageContent(
+            inner_content=response,
+            ai_model_id=self.ai_model_id,
+            metadata=response_metadata,
+            role=AuthorRole(response.role),
+            items=items,
+            finish_reason=finish_reason,
+        )
+
+    def _create_streaming_chat_message_content(
+        self,
+        stream_event: RawContentBlockDeltaEvent | RawMessageDeltaEvent,
+        content_block_idx: int,
+        role: str | None = None,
+        metadata: dict[str, Any] = {},
+    ) -> StreamingChatMessageContent:
+        """Create a streaming chat message content object from a choice."""
+        text_content = ""
+
+        if stream_event.delta and hasattr(stream_event.delta, "text"):
+            text_content = stream_event.delta.text
+
+        items: list[STREAMING_ITEM_TYPES] = [StreamingTextContent(choice_index=content_block_idx, text=text_content)]
+
+        finish_reason = None
+        if isinstance(stream_event, RawMessageDeltaEvent):
+            if stream_event.delta.stop_reason:
+                finish_reason = ANTHROPIC_TO_SEMANTIC_KERNEL_FINISH_REASON_MAP[stream_event.delta.stop_reason]
+
+            metadata["usage"]["output_tokens"] = stream_event.usage.output_tokens
+
+        return StreamingChatMessageContent(
+            choice_index=content_block_idx,
+            inner_content=stream_event,
+            ai_model_id=self.ai_model_id,
+            metadata=metadata,
+            role=AuthorRole(role) if role else AuthorRole.ASSISTANT,
+            finish_reason=finish_reason,
+            items=items,
+        )
+
+    def get_prompt_execution_settings_class(self) -> "type[AnthropicChatPromptExecutionSettings]":
+        """Create a request settings object."""
+        return AnthropicChatPromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/anthropic/settings/anthropic_settings.py

@@ -0,0 +1,29 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from pydantic import SecretStr
+
+from semantic_kernel.kernel_pydantic import KernelBaseSettings
+
+
+class AnthropicSettings(KernelBaseSettings):
+    """Anthropic model settings.
+
+    The settings are first loaded from environment variables with the prefix 'ANTHROPIC_'. 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 'ANTHROPIC_' are:
+    - api_key: ANTHROPIC API key, see https://console.mistral.ai/api-keys
+        (Env var ANTHROPIC_API_KEY)
+    - chat_model_id: The Anthropic chat model ID to use see https://docs.mistral.ai/getting-started/models/.
+        (Env var ANTHROPIC_CHAT_MODEL_ID)
+    - env_file_path: if provided, the .env settings are read from this file path location
+    """
+
+    env_prefix: ClassVar[str] = "ANTHROPIC_"
+
+    api_key: SecretStr
+    chat_model_id: str | None = None

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

@@ -0,0 +1,21 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.ai.azure_ai_inference.azure_ai_inference_prompt_execution_settings import (
+    AzureAIInferenceChatPromptExecutionSettings,
+    AzureAIInferenceEmbeddingPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.azure_ai_inference.azure_ai_inference_settings import AzureAIInferenceSettings
+from semantic_kernel.connectors.ai.azure_ai_inference.services.azure_ai_inference_chat_completion import (
+    AzureAIInferenceChatCompletion,
+)
+from semantic_kernel.connectors.ai.azure_ai_inference.services.azure_ai_inference_text_embedding import (
+    AzureAIInferenceTextEmbedding,
+)
+
+__all__ = [
+    "AzureAIInferenceChatCompletion",
+    "AzureAIInferenceChatPromptExecutionSettings",
+    "AzureAIInferenceEmbeddingPromptExecutionSettings",
+    "AzureAIInferenceSettings",
+    "AzureAIInferenceTextEmbedding",
+]

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/azure_ai_inference/azure_ai_inference_prompt_execution_settings.py

@@ -0,0 +1,55 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Any, Literal
+
+from pydantic import Field
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+
+@experimental_class
+class AzureAIInferencePromptExecutionSettings(PromptExecutionSettings):
+    """Azure AI Inference Prompt Execution Settings.
+
+    Note:
+        `extra_parameters` is a dictionary to pass additional model-specific parameters to the model.
+    """
+
+    frequency_penalty: float | None = Field(None, ge=-2, le=2)
+    max_tokens: int | None = Field(None, gt=0)
+    presence_penalty: float | None = Field(None, ge=-2, le=2)
+    seed: int | None = None
+    stop: str | None = None
+    temperature: float | None = Field(None, ge=0.0, le=1.0)
+    top_p: float | None = Field(None, ge=0.0, le=1.0)
+    extra_parameters: dict[str, Any] | None = None
+
+
+@experimental_class
+class AzureAIInferenceChatPromptExecutionSettings(AzureAIInferencePromptExecutionSettings):
+    """Azure AI Inference Chat Prompt Execution Settings."""
+
+    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.",
+    )
+
+
+@experimental_class
+class AzureAIInferenceEmbeddingPromptExecutionSettings(PromptExecutionSettings):
+    """Azure AI Inference Embedding Prompt Execution Settings.
+
+    Note:
+        `extra_parameters` is a dictionary to pass additional model-specific parameters to the model.
+    """
+
+    dimensions: int | None = Field(None, gt=0)
+    encoding_format: Literal["base64", "binary", "float", "int8", "ubinary", "uint8"] | None = None
+    input_type: Literal["text", "query", "document"] | None = None
+    extra_parameters: dict[str, str] | None = None

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/azure_ai_inference/azure_ai_inference_settings.py

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from pydantic import SecretStr
+
+from semantic_kernel.kernel_pydantic import HttpsUrl, KernelBaseSettings
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+
+@experimental_class
+class AzureAIInferenceSettings(KernelBaseSettings):
+    """Azure AI Inference settings.
+
+    The settings are first loaded from environment variables with
+    the prefix 'AZURE_AI_INFERENCE_'.
+    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.
+
+    Required settings for prefix 'AZURE_AI_INFERENCE_' are:
+    - endpoint: HttpsUrl - The endpoint of the Azure AI Inference service deployment.
+                This value can be found in the Keys & Endpoint section when examining
+                your resource from the Azure portal.
+                (Env var AZURE_AI_INFERENCE_ENDPOINT)
+    - api_key: SecretStr - The API key for the Azure AI Inference service deployment.
+                This value can be found in the Keys & Endpoint section when examining
+                your resource from the Azure portal. You can use either KEY1 or KEY2.
+                (Env var AZURE_AI_INFERENCE_API_KEY)
+    """
+
+    env_prefix: ClassVar[str] = "AZURE_AI_INFERENCE_"
+
+    endpoint: HttpsUrl
+    api_key: SecretStr

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/azure_ai_inference/services/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Microsoft. All rights reserved.

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/azure_ai_inference/services/azure_ai_inference_base.py

@@ -0,0 +1,25 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import contextlib
+from abc import ABC
+from typing import ClassVar
+
+from azure.ai.inference.aio import ChatCompletionsClient, EmbeddingsClient
+
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+
+@experimental_class
+class AzureAIInferenceBase(KernelBaseModel, ABC):
+    """Azure AI Inference Chat Completion Service."""
+
+    MODEL_PROVIDER_NAME: ClassVar[str] = "azureai"
+
+    client: ChatCompletionsClient | EmbeddingsClient
+
+    def __del__(self) -> None:
+        """Close the client when the object is deleted."""
+        with contextlib.suppress(Exception):
+            asyncio.get_running_loop().create_task(self.client.close())