semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/contents/chat_history.py

@@ -0,0 +1,339 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Generator
+from functools import singledispatchmethod
+from html import unescape
+from typing import Any
+from xml.etree.ElementTree import Element, tostring  # nosec
+
+from defusedxml.ElementTree import XML, ParseError
+from pydantic import field_validator
+
+from semantic_kernel.contents.chat_message_content import ChatMessageContent
+from semantic_kernel.contents.const import CHAT_HISTORY_TAG, CHAT_MESSAGE_CONTENT_TAG
+from semantic_kernel.contents.kernel_content import KernelContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.exceptions import ContentInitializationError, ContentSerializationError
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class ChatHistory(KernelBaseModel):
+    """This class holds the history of chat messages from a chat conversation.
+
+    Note: the constructor takes a system_message parameter, which is not part
+    of the class definition. This is to allow the system_message to be passed in
+    as a keyword argument, but not be part of the class definition.
+
+    Attributes:
+        messages (List[ChatMessageContent]): The list of chat messages in the history.
+    """
+
+    messages: list[ChatMessageContent]
+
+    def __init__(self, **data: Any):
+        """Initializes a new instance of the ChatHistory class.
+
+        Optionally incorporating a message and/or a system message at the beginning of the chat history.
+
+        This constructor allows for flexible initialization with chat messages and an optional messages or a
+        system message. If both 'messages' (a list of ChatMessageContent instances) and 'system_message' are
+        provided, the 'system_message' is prepended to the list of messages, ensuring it appears as the first
+        message in the history. If only 'system_message' is provided without any 'messages', the chat history is
+        initialized with the 'system_message' as its first item. If 'messages' are provided without a
+        'system_message', the chat history is initialized with the provided messages as is.
+
+        Note: The 'system_message' is not retained as part of the class's attributes; it's used during
+        initialization and then discarded. The rest of the keyword arguments are passed to the superclass
+        constructor and handled according to the Pydantic model's behavior.
+
+        Args:
+            **data: Arbitrary keyword arguments.
+                The constructor looks for two optional keys:
+                - 'messages': Optional[List[ChatMessageContent]], a list of chat messages to include in the history.
+                - 'system_message' Optional[str]: An optional string representing a system-generated message to be
+                    included at the start of the chat history.
+
+        """
+        system_message_content = data.pop("system_message", None)
+
+        if system_message_content:
+            system_message = ChatMessageContent(role=AuthorRole.SYSTEM, content=system_message_content)
+
+            if "messages" in data:
+                data["messages"] = [system_message] + data["messages"]
+            else:
+                data["messages"] = [system_message]
+        if "messages" not in data:
+            data["messages"] = []
+        super().__init__(**data)
+
+    @field_validator("messages", mode="before")
+    @classmethod
+    def _validate_messages(cls, messages: list[ChatMessageContent]) -> list[ChatMessageContent]:
+        if not messages:
+            return messages
+        out_msgs: list[ChatMessageContent] = []
+        for message in messages:
+            if isinstance(message, dict):
+                out_msgs.append(ChatMessageContent.model_validate(message))
+            else:
+                out_msgs.append(message)
+        return out_msgs
+
+    @singledispatchmethod
+    def add_system_message(self, content: str | list[KernelContent], **kwargs) -> None:
+        """Add a system message to the chat history."""
+        raise NotImplementedError
+
+    @add_system_message.register
+    def add_system_message_str(self, content: str, **kwargs: Any) -> None:
+        """Add a system message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.SYSTEM, content=content, **kwargs))
+
+    @add_system_message.register(list)
+    def add_system_message_list(self, content: list[KernelContent], **kwargs: Any) -> None:
+        """Add a system message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.SYSTEM, items=content, **kwargs))
+
+    @singledispatchmethod
+    def add_user_message(self, content: str | list[KernelContent], **kwargs: Any) -> None:
+        """Add a user message to the chat history."""
+        raise NotImplementedError
+
+    @add_user_message.register
+    def add_user_message_str(self, content: str, **kwargs: Any) -> None:
+        """Add a user message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.USER, content=content, **kwargs))
+
+    @add_user_message.register(list)
+    def add_user_message_list(self, content: list[KernelContent], **kwargs: Any) -> None:
+        """Add a user message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.USER, items=content, **kwargs))
+
+    @singledispatchmethod
+    def add_assistant_message(self, content: str | list[KernelContent], **kwargs: Any) -> None:
+        """Add an assistant message to the chat history."""
+        raise NotImplementedError
+
+    @add_assistant_message.register
+    def add_assistant_message_str(self, content: str, **kwargs: Any) -> None:
+        """Add an assistant message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.ASSISTANT, content=content, **kwargs))
+
+    @add_assistant_message.register(list)
+    def add_assistant_message_list(self, content: list[KernelContent], **kwargs: Any) -> None:
+        """Add an assistant message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.ASSISTANT, items=content, **kwargs))
+
+    @singledispatchmethod
+    def add_tool_message(self, content: str | list[KernelContent], **kwargs: Any) -> None:
+        """Add a tool message to the chat history."""
+        raise NotImplementedError
+
+    @add_tool_message.register
+    def add_tool_message_str(self, content: str, **kwargs: Any) -> None:
+        """Add a tool message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.TOOL, content=content, **kwargs))
+
+    @add_tool_message.register(list)
+    def add_tool_message_list(self, content: list[KernelContent], **kwargs: Any) -> None:
+        """Add a tool message to the chat history."""
+        self.add_message(message=self._prepare_for_add(role=AuthorRole.TOOL, items=content, **kwargs))
+
+    def add_message(
+        self,
+        message: ChatMessageContent | dict[str, Any],
+        encoding: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        """Add a message to the history.
+
+        This method accepts either a ChatMessageContent instance or a
+        dictionary with the necessary information to construct a ChatMessageContent instance.
+
+        Args:
+            message (Union[ChatMessageContent, dict]): The message to add, either as
+                a pre-constructed ChatMessageContent instance or a dictionary specifying 'role' and 'content'.
+            encoding (Optional[str]): The encoding of the message. Required if 'message' is a dict.
+            metadata (Optional[dict[str, Any]]): Any metadata to attach to the message. Required if 'message' is a dict.
+        """
+        if isinstance(message, ChatMessageContent):
+            self.messages.append(message)
+            return
+        if "role" not in message:
+            raise ContentInitializationError(f"Dictionary must contain at least the role. Got: {message}")
+        if encoding:
+            message["encoding"] = encoding
+        if metadata:
+            message["metadata"] = metadata
+        self.messages.append(ChatMessageContent(**message))
+
+    def _prepare_for_add(
+        self, role: AuthorRole, content: str | None = None, items: list[KernelContent] | None = None, **kwargs: Any
+    ) -> dict[str, str]:
+        """Prepare a message to be added to the history."""
+        kwargs["role"] = role
+        if content:
+            kwargs["content"] = content
+        if items:
+            kwargs["items"] = items
+        return kwargs
+
+    def remove_message(self, message: ChatMessageContent) -> bool:
+        """Remove a message from the history.
+
+        Args:
+            message (ChatMessageContent): The message to remove.
+
+        Returns:
+            bool: True if the message was removed, False if the message was not found.
+        """
+        try:
+            self.messages.remove(message)
+            return True
+        except ValueError:
+            return False
+
+    def __len__(self) -> int:
+        """Return the number of messages in the history."""
+        return len(self.messages)
+
+    def __getitem__(self, index: int) -> ChatMessageContent:
+        """Get a message from the history using the [] operator.
+
+        Args:
+            index (int): The index of the message to get.
+
+        Returns:
+            ChatMessageContent: The message at the specified index.
+        """
+        return self.messages[index]
+
+    def __contains__(self, item: ChatMessageContent) -> bool:
+        """Check if a message is in the history.
+
+        Args:
+            item (ChatMessageContent): The message to check for.
+
+        Returns:
+            bool: True if the message is in the history, False otherwise.
+        """
+        return item in self.messages
+
+    def __str__(self) -> str:
+        """Return a string representation of the history."""
+        chat_history_xml = Element(CHAT_HISTORY_TAG)
+        for message in self.messages:
+            chat_history_xml.append(message.to_element())
+        return tostring(chat_history_xml, encoding="unicode", short_empty_elements=True)
+
+    def to_prompt(self) -> str:
+        """Return a string representation of the history."""
+        chat_history_xml = Element(CHAT_HISTORY_TAG)
+        for message in self.messages:
+            chat_history_xml.append(message.to_element())
+        return tostring(chat_history_xml, encoding="unicode", short_empty_elements=True)
+
+    def __iter__(self) -> Generator[ChatMessageContent, None, None]:  # type: ignore
+        """Return an iterator over the messages in the history."""
+        yield from self.messages
+
+    def __eq__(self, other: Any) -> bool:
+        """Check if two ChatHistory instances are equal."""
+        if not isinstance(other, ChatHistory):
+            return False
+
+        return self.messages == other.messages
+
+    @classmethod
+    def from_rendered_prompt(cls, rendered_prompt: str) -> "ChatHistory":
+        """Create a ChatHistory instance from a rendered prompt.
+
+        Args:
+            rendered_prompt (str): The rendered prompt to convert to a ChatHistory instance.
+
+        Returns:
+            ChatHistory: The ChatHistory instance created from the rendered prompt.
+        """
+        prompt_tag = "root"
+        messages: list["ChatMessageContent"] = []
+        prompt = rendered_prompt.strip()
+        try:
+            xml_prompt = XML(text=f"<{prompt_tag}>{prompt}</{prompt_tag}>")
+        except ParseError as exc:
+            logger.info(f"Could not parse prompt {prompt} as xml, treating as text, error was: {exc}")
+            return cls(messages=[ChatMessageContent(role=AuthorRole.USER, content=unescape(prompt))])
+        if xml_prompt.text and xml_prompt.text.strip():
+            messages.append(ChatMessageContent(role=AuthorRole.SYSTEM, content=unescape(xml_prompt.text.strip())))
+        for item in xml_prompt:
+            if item.tag == CHAT_MESSAGE_CONTENT_TAG:
+                messages.append(ChatMessageContent.from_element(item))
+            elif item.tag == CHAT_HISTORY_TAG:
+                for message in item:
+                    messages.append(ChatMessageContent.from_element(message))
+            if item.tail and item.tail.strip():
+                messages.append(ChatMessageContent(role=AuthorRole.USER, content=unescape(item.tail.strip())))
+        if len(messages) == 1 and messages[0].role == AuthorRole.SYSTEM:
+            messages[0].role = AuthorRole.USER
+        return cls(messages=messages)
+
+    def serialize(self) -> str:
+        """Serializes the ChatHistory instance to a JSON string.
+
+        Returns:
+            str: A JSON string representation of the ChatHistory instance.
+
+        Raises:
+            ValueError: If the ChatHistory instance cannot be serialized to JSON.
+        """
+        try:
+            return self.model_dump_json(indent=2, exclude_none=True)
+        except Exception as e:  # pragma: no cover
+            raise ContentSerializationError(f"Unable to serialize ChatHistory to JSON: {e}") from e
+
+    @classmethod
+    def restore_chat_history(cls, chat_history_json: str) -> "ChatHistory":
+        """Restores a ChatHistory instance from a JSON string.
+
+        Args:
+            chat_history_json (str): The JSON string to deserialize
+                into a ChatHistory instance.
+
+        Returns:
+            ChatHistory: The deserialized ChatHistory instance.
+
+        Raises:
+            ValueError: If the JSON string is invalid or the deserialized data
+                fails validation.
+        """
+        try:
+            return ChatHistory.model_validate_json(chat_history_json)
+        except Exception as e:
+            raise ContentInitializationError(f"Invalid JSON format: {e}")
+
+    def store_chat_history_to_file(self, file_path: str) -> None:
+        """Stores the serialized ChatHistory to a file.
+
+        Args:
+            file_path (str): The path to the file where the serialized data will be stored.
+        """
+        json_str = self.serialize()
+        with open(file_path, "w") as file:
+            file.write(json_str)
+
+    @classmethod
+    def load_chat_history_from_file(cls, file_path: str) -> "ChatHistory":
+        """Loads the ChatHistory from a file.
+
+        Args:
+            file_path (str): The path to the file from which to load the ChatHistory.
+
+        Returns:
+            ChatHistory: The deserialized ChatHistory instance.
+        """
+        with open(file_path) as file:
+            json_str = file.read()
+        return cls.restore_chat_history(json_str)

semantic_kernel-1.8.3/semantic_kernel/contents/chat_message_content.py

@@ -0,0 +1,305 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from enum import Enum
+from html import unescape
+from typing import Annotated, Any, ClassVar, Literal, overload
+from xml.etree.ElementTree import Element  # nosec
+
+from defusedxml import ElementTree
+from pydantic import Field
+
+from semantic_kernel.contents.annotation_content import AnnotationContent
+from semantic_kernel.contents.const import (
+    ANNOTATION_CONTENT_TAG,
+    CHAT_MESSAGE_CONTENT_TAG,
+    DISCRIMINATOR_FIELD,
+    FILE_REFERENCE_CONTENT_TAG,
+    FUNCTION_CALL_CONTENT_TAG,
+    FUNCTION_RESULT_CONTENT_TAG,
+    IMAGE_CONTENT_TAG,
+    TEXT_CONTENT_TAG,
+    ContentTypes,
+)
+from semantic_kernel.contents.file_reference_content import FileReferenceContent
+from semantic_kernel.contents.function_call_content import FunctionCallContent
+from semantic_kernel.contents.function_result_content import FunctionResultContent
+from semantic_kernel.contents.image_content import ImageContent
+from semantic_kernel.contents.kernel_content import KernelContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.contents.utils.finish_reason import FinishReason
+from semantic_kernel.exceptions.content_exceptions import ContentInitializationError
+
+TAG_CONTENT_MAP = {
+    ANNOTATION_CONTENT_TAG: AnnotationContent,
+    TEXT_CONTENT_TAG: TextContent,
+    FILE_REFERENCE_CONTENT_TAG: FileReferenceContent,
+    FUNCTION_CALL_CONTENT_TAG: FunctionCallContent,
+    FUNCTION_RESULT_CONTENT_TAG: FunctionResultContent,
+    IMAGE_CONTENT_TAG: ImageContent,
+}
+
+ITEM_TYPES = (
+    AnnotationContent | ImageContent | TextContent | FunctionResultContent | FunctionCallContent | FileReferenceContent
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ChatMessageContent(KernelContent):
+    """This is the class for chat message response content.
+
+    All Chat Completion Services should return an instance of this class as response.
+    Or they can implement their own subclass of this class and return an instance.
+
+    Args:
+        inner_content: Optional[Any] - The inner content of the response,
+            this should hold all the information from the response so even
+            when not creating a subclass a developer can leverage the full thing.
+        ai_model_id: Optional[str] - The id of the AI model that generated this response.
+        metadata: Dict[str, Any] - Any metadata that should be attached to the response.
+        role: ChatRole - The role of the chat message.
+        content: Optional[str] - The text of the response.
+        encoding: Optional[str] - The encoding of the text.
+
+    Methods:
+        __str__: Returns the content of the response.
+    """
+
+    content_type: Literal[ContentTypes.CHAT_MESSAGE_CONTENT] = Field(CHAT_MESSAGE_CONTENT_TAG, init=False)  # type: ignore
+    tag: ClassVar[str] = CHAT_MESSAGE_CONTENT_TAG
+    role: AuthorRole
+    name: str | None = None
+    items: list[Annotated[ITEM_TYPES, Field(..., discriminator=DISCRIMINATOR_FIELD)]] = Field(default_factory=list)
+    encoding: str | None = None
+    finish_reason: FinishReason | None = None
+
+    @overload
+    def __init__(
+        self,
+        role: AuthorRole,
+        items: list[ITEM_TYPES],
+        name: str | None = None,
+        inner_content: Any | None = None,
+        encoding: str | None = None,
+        finish_reason: FinishReason | None = None,
+        ai_model_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        role: AuthorRole,
+        content: str,
+        name: str | None = None,
+        inner_content: Any | None = None,
+        encoding: str | None = None,
+        finish_reason: FinishReason | None = None,
+        ai_model_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None: ...
+
+    def __init__(  # type: ignore
+        self,
+        role: AuthorRole,
+        items: list[ITEM_TYPES] | None = None,
+        content: str | None = None,
+        inner_content: Any | None = None,
+        name: str | None = None,
+        encoding: str | None = None,
+        finish_reason: FinishReason | None = None,
+        ai_model_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ):
+        """Create a ChatMessageContent instance.
+
+        Args:
+            role: AuthorRole - The role of the chat message.
+            items: list[TextContent, StreamingTextContent, FunctionCallContent, FunctionResultContent, ImageContent]
+                 - The content.
+            content: str - The text of the response.
+            inner_content: Optional[Any] - The inner content of the response,
+                this should hold all the information from the response so even
+                when not creating a subclass a developer can leverage the full thing.
+            name: Optional[str] - The name of the response.
+            encoding: Optional[str] - The encoding of the text.
+            finish_reason: Optional[FinishReason] - The reason the response was finished.
+            ai_model_id: Optional[str] - The id of the AI model that generated this response.
+            metadata: Dict[str, Any] - Any metadata that should be attached to the response.
+            **kwargs: Any - Any additional fields to set on the instance.
+        """
+        kwargs["role"] = role
+        if encoding:
+            kwargs["encoding"] = encoding
+        if finish_reason:
+            kwargs["finish_reason"] = finish_reason
+        if name:
+            kwargs["name"] = name
+        if content:
+            item = TextContent(
+                ai_model_id=ai_model_id,
+                inner_content=inner_content,
+                metadata=metadata or {},
+                text=content,
+                encoding=encoding,
+            )
+            if items:
+                items.append(item)
+            else:
+                items = [item]
+        if items:
+            kwargs["items"] = items
+        if inner_content:
+            kwargs["inner_content"] = inner_content
+        if metadata:
+            kwargs["metadata"] = metadata
+        if ai_model_id:
+            kwargs["ai_model_id"] = ai_model_id
+        super().__init__(
+            **kwargs,
+        )
+
+    @property
+    def content(self) -> str:
+        """Get the content of the response, will find the first TextContent's text."""
+        for item in self.items:
+            if isinstance(item, TextContent):
+                return item.text
+        return ""
+
+    @content.setter
+    def content(self, value: str):
+        """Set the content of the response."""
+        if not value:
+            logger.warning(
+                "Setting empty content on ChatMessageContent does not work, "
+                "you can do this through the underlying items if needed, ignoring."
+            )
+            return
+        for item in self.items:
+            if isinstance(item, TextContent):
+                item.text = value
+                item.encoding = self.encoding
+                return
+        self.items.append(
+            TextContent(
+                ai_model_id=self.ai_model_id,
+                inner_content=self.inner_content,
+                metadata=self.metadata,
+                text=value,
+                encoding=self.encoding,
+            )
+        )
+
+    def __str__(self) -> str:
+        """Get the content of the response as a string."""
+        return self.content or ""
+
+    def to_element(self) -> "Element":
+        """Convert the ChatMessageContent to an XML Element.
+
+        Args:
+            root_key: str - The key to use for the root of the XML Element.
+
+        Returns:
+            Element - The XML Element representing the ChatMessageContent.
+        """
+        root = Element(self.tag)
+        for field in self.model_fields_set:
+            if field not in ["role", "name", "encoding", "finish_reason", "ai_model_id"]:
+                continue
+            value = getattr(self, field)
+            if isinstance(value, Enum):
+                value = value.value
+            root.set(field, value)
+        for index, item in enumerate(self.items):
+            root.insert(index, item.to_element())
+        return root
+
+    @classmethod
+    def from_element(cls, element: Element) -> "ChatMessageContent":
+        """Create a new instance of ChatMessageContent from an XML element.
+
+        Args:
+            element: Element - The XML Element to create the ChatMessageContent from.
+
+        Returns:
+            ChatMessageContent - The new instance of ChatMessageContent or a subclass.
+        """
+        if element.tag != cls.tag:
+            raise ContentInitializationError(f"Element tag is not {cls.tag}")  # pragma: no cover
+        kwargs: dict[str, Any] = {key: value for key, value in element.items()}
+        items: list[KernelContent] = []
+        if element.text:
+            items.append(TextContent(text=unescape(element.text)))
+        for child in element:
+            if child.tag not in TAG_CONTENT_MAP:
+                logger.warning('Unknown tag "%s" in ChatMessageContent, treating as text', child.tag)
+                text = ElementTree.tostring(child, encoding="unicode", short_empty_elements=False)
+                items.append(TextContent(text=unescape(text) or ""))
+            else:
+                items.append(TAG_CONTENT_MAP[child.tag].from_element(child))  # type: ignore
+        if len(items) == 1 and isinstance(items[0], TextContent):
+            kwargs["content"] = items[0].text
+        elif all(isinstance(item, TextContent) for item in items):
+            kwargs["content"] = "".join(item.text for item in items)  # type: ignore
+        else:
+            kwargs["items"] = items
+        if "choice_index" in kwargs and cls is ChatMessageContent:
+            logger.info(
+                "Seems like you are trying to create a StreamingChatMessageContent, "
+                "use StreamingChatMessageContent.from_element instead, ignoring that field "
+                "and creating a ChatMessageContent instance."
+            )
+            kwargs.pop("choice_index")
+        return cls(**kwargs)
+
+    def to_prompt(self) -> str:
+        """Convert the ChatMessageContent to a prompt.
+
+        Returns:
+            str - The prompt from the ChatMessageContent.
+        """
+        root = self.to_element()
+        return ElementTree.tostring(root, encoding=self.encoding or "unicode", short_empty_elements=False)
+
+    def to_dict(self, role_key: str = "role", content_key: str = "content") -> dict[str, Any]:
+        """Serialize the ChatMessageContent to a dictionary.
+
+        Returns:
+            dict - The dictionary representing the ChatMessageContent.
+        """
+        ret: dict[str, Any] = {
+            role_key: self.role.value,
+        }
+        if self.role == AuthorRole.ASSISTANT and any(isinstance(item, FunctionCallContent) for item in self.items):
+            ret["tool_calls"] = [item.to_dict() for item in self.items if isinstance(item, FunctionCallContent)]
+        else:
+            ret[content_key] = self._parse_items()
+        if self.role == AuthorRole.TOOL:
+            assert isinstance(self.items[0], FunctionResultContent)  # nosec
+            ret["tool_call_id"] = self.items[0].id or ""
+        if self.role != AuthorRole.TOOL and self.name:
+            ret["name"] = self.name
+        return ret
+
+    def _parse_items(self) -> str | list[dict[str, Any]]:
+        """Parse the items of the ChatMessageContent.
+
+        Returns:
+            str | list of dicts - The parsed items.
+        """
+        if len(self.items) == 1 and isinstance(self.items[0], TextContent):
+            return self.items[0].text
+        if len(self.items) == 1 and isinstance(self.items[0], FunctionResultContent):
+            return str(self.items[0].result)
+        return [item.to_dict() for item in self.items]
+
+    def __hash__(self) -> int:
+        """Return the hash of the chat message content."""
+        return hash((self.tag, self.role, self.content, self.encoding, self.finish_reason, *self.items))

semantic_kernel-1.8.3/semantic_kernel/contents/const.py

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft. All rights reserved.
+from enum import Enum
+from typing import Final
+
+CHAT_MESSAGE_CONTENT_TAG: Final[str] = "message"
+CHAT_HISTORY_TAG: Final[str] = "chat_history"
+TEXT_CONTENT_TAG: Final[str] = "text"
+IMAGE_CONTENT_TAG: Final[str] = "image"
+ANNOTATION_CONTENT_TAG: Final[str] = "annotation"
+BINARY_CONTENT_TAG: Final[str] = "binary"
+FILE_REFERENCE_CONTENT_TAG: Final[str] = "file_reference"
+FUNCTION_CALL_CONTENT_TAG: Final[str] = "function_call"
+FUNCTION_RESULT_CONTENT_TAG: Final[str] = "function_result"
+DISCRIMINATOR_FIELD: Final[str] = "content_type"
+
+
+class ContentTypes(str, Enum):
+    """Content types enumeration."""
+
+    ANNOTATION_CONTENT = ANNOTATION_CONTENT_TAG
+    BINARY_CONTENT = BINARY_CONTENT_TAG
+    CHAT_MESSAGE_CONTENT = CHAT_MESSAGE_CONTENT_TAG
+    IMAGE_CONTENT = IMAGE_CONTENT_TAG
+    FILE_REFERENCE_CONTENT = FILE_REFERENCE_CONTENT_TAG
+    FUNCTION_CALL_CONTENT = FUNCTION_CALL_CONTENT_TAG
+    FUNCTION_RESULT_CONTENT = FUNCTION_RESULT_CONTENT_TAG
+    TEXT_CONTENT = TEXT_CONTENT_TAG