semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/prompt_template/jinja2_prompt_template.py

@@ -0,0 +1,117 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional
+
+from jinja2 import BaseLoader, TemplateError
+from jinja2.sandbox import ImmutableSandboxedEnvironment
+from pydantic import PrivateAttr, field_validator
+
+from semantic_kernel.exceptions import Jinja2TemplateRenderException
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.prompt_template.const import JINJA2_TEMPLATE_FORMAT_NAME
+from semantic_kernel.prompt_template.prompt_template_base import PromptTemplateBase
+from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+from semantic_kernel.prompt_template.utils import JINJA2_SYSTEM_HELPERS
+from semantic_kernel.prompt_template.utils.template_function_helpers import create_template_helper_from_function
+
+if TYPE_CHECKING:
+    from semantic_kernel.kernel import Kernel
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class Jinja2PromptTemplate(PromptTemplateBase):
+    """Creates and renders Jinja2 prompt templates to text.
+
+    Jinja2 templates support advanced features such as variable substitution, control structures,
+    and inheritance, making it possible to dynamically generate text based on input arguments
+    and predefined functions. This class leverages Jinja2's flexibility to render prompts that
+    can include conditional logic, loops, and functions, based on the provided template configuration
+    and arguments.
+
+    Note that the fully qualified function name (in the form of "plugin-function") is not allowed
+    in Jinja2 because of the hyphen. Therefore, the function name is replaced with an underscore,
+    which are allowed in Python function names.
+
+    Args:
+        prompt_template_config (PromptTemplateConfig): The configuration object for the prompt template.
+            This should specify the template format as 'jinja2' and include any necessary
+            configuration details required for rendering the template.
+        allow_dangerously_set_content (bool = False): Allow content without encoding throughout, this overrides
+            the same settings in the prompt template config and input variables.
+            This reverts the behavior to unencoded input.
+
+    Raises:
+        ValueError: If the template format specified in the configuration is not 'jinja2'.
+        Jinja2TemplateSyntaxError: If there is a syntax error in the Jinja2 template.
+    """
+
+    _env: ImmutableSandboxedEnvironment | None = PrivateAttr()
+
+    @field_validator("prompt_template_config")
+    @classmethod
+    def validate_template_format(cls, v: "PromptTemplateConfig") -> "PromptTemplateConfig":
+        """Validate the template format."""
+        if v.template_format != JINJA2_TEMPLATE_FORMAT_NAME:
+            raise ValueError(f"Invalid prompt template format: {v.template_format}. Expected: jinja2")
+        return v
+
+    def model_post_init(self, _: Any) -> None:
+        """Post init model."""
+        if not self.prompt_template_config.template:
+            self._env = None
+            return
+        self._env = ImmutableSandboxedEnvironment(loader=BaseLoader(), enable_async=True)
+
+    async def render(self, kernel: "Kernel", arguments: Optional["KernelArguments"] = None) -> str:
+        """Render the prompt template.
+
+        Using the prompt template, replace the variables with their values
+        and execute the functions replacing their reference with the
+        function result.
+
+        Args:
+            kernel: The kernel instance
+            arguments: The kernel arguments
+
+        Returns:
+            The prompt template ready to be used for an AI request
+        """
+        if not self._env:
+            return ""
+        if arguments is None:
+            arguments = KernelArguments()
+
+        arguments = self._get_trusted_arguments(arguments)
+        allow_unsafe_function_output = self._get_allow_dangerously_set_function_output()
+        helpers: dict[str, Callable[..., Any]] = {}
+        helpers.update(JINJA2_SYSTEM_HELPERS)
+        for plugin in kernel.plugins.values():
+            helpers.update(
+                {
+                    function.fully_qualified_name.replace("-", "_"): create_template_helper_from_function(
+                        function,
+                        kernel,
+                        arguments,
+                        self.prompt_template_config.template_format,
+                        allow_unsafe_function_output,
+                        enable_async=True,
+                    )
+                    for function in plugin
+                }
+            )
+        if self.prompt_template_config.template is None:
+            raise Jinja2TemplateRenderException("Error rendering template, template is None")
+        try:
+            template = self._env.from_string(self.prompt_template_config.template, globals=helpers)
+            return await template.render_async(**arguments)
+        except TemplateError as exc:
+            logger.error(
+                f"Error rendering prompt template: {self.prompt_template_config.template} with arguments: {arguments}"
+            )
+            raise Jinja2TemplateRenderException(
+                f"Error rendering prompt template: {self.prompt_template_config.template} with "
+                f"arguments: {arguments}: error: {exc}"
+            ) from exc

semantic_kernel-1.8.3/semantic_kernel/prompt_template/kernel_prompt_template.py

@@ -0,0 +1,130 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from html import escape
+from typing import TYPE_CHECKING, Any
+
+from pydantic import PrivateAttr, field_validator
+
+from semantic_kernel.exceptions import TemplateRenderException
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.prompt_template.const import KERNEL_TEMPLATE_FORMAT_NAME
+from semantic_kernel.prompt_template.input_variable import InputVariable
+from semantic_kernel.prompt_template.prompt_template_base import PromptTemplateBase
+from semantic_kernel.template_engine.blocks.block import Block
+from semantic_kernel.template_engine.blocks.code_block import CodeBlock
+from semantic_kernel.template_engine.blocks.named_arg_block import NamedArgBlock
+from semantic_kernel.template_engine.blocks.var_block import VarBlock
+from semantic_kernel.template_engine.template_tokenizer import TemplateTokenizer
+
+if TYPE_CHECKING:
+    from semantic_kernel.kernel import Kernel
+    from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class KernelPromptTemplate(PromptTemplateBase):
+    """Create a Kernel prompt template."""
+
+    _blocks: list[Block] = PrivateAttr(default_factory=list)
+
+    @field_validator("prompt_template_config")
+    @classmethod
+    def validate_template_format(cls, v: "PromptTemplateConfig") -> "PromptTemplateConfig":
+        """Validate the template format."""
+        if v.template_format != KERNEL_TEMPLATE_FORMAT_NAME:
+            raise ValueError(f"Invalid prompt template format: {v.template_format}. Expected: semantic-kernel")
+        return v
+
+    def model_post_init(self, _: Any) -> None:
+        """Post init model."""
+        self._blocks = self.extract_blocks()
+        # Add all of the existing input variables to our known set. We'll avoid adding any
+        # dynamically discovered input variables with the same name.
+        seen = {iv.name.lower() for iv in self.prompt_template_config.input_variables}
+
+        # Enumerate every block in the template, adding any variables that are referenced.
+        for block in self._blocks:
+            if isinstance(block, VarBlock):
+                # Add all variables from variable blocks, e.g. "{{$a}}".
+                self._add_if_missing(block.name, seen)
+                continue
+            if isinstance(block, CodeBlock):
+                for sub_block in block.tokens:
+                    if isinstance(sub_block, VarBlock):
+                        # Add all variables from code blocks, e.g. "{{p.bar $b}}".
+                        self._add_if_missing(sub_block.name, seen)
+                        continue
+                    if isinstance(sub_block, NamedArgBlock) and sub_block.variable:
+                        # Add all variables from named arguments, e.g. "{{p.bar b = $b}}".
+                        # represents a named argument for a function call.
+                        # For example, in the template {{ MyPlugin.MyFunction var1=$boo }}, var1=$boo
+                        # is a named arg block.
+                        self._add_if_missing(sub_block.variable.name, seen)
+
+    def extract_blocks(self) -> list[Block]:
+        """Given the prompt template, extract all the blocks (text, variables, function calls)."""
+        logger.debug(f"Extracting blocks from template: {self.prompt_template_config.template}")
+        if not self.prompt_template_config.template:
+            return []
+        return TemplateTokenizer.tokenize(self.prompt_template_config.template)
+
+    def _add_if_missing(self, variable_name: str, seen: set):
+        # Convert variable_name to lower case to handle case-insensitivity
+        if variable_name and variable_name.lower() not in seen:
+            seen.add(variable_name.lower())
+            self.prompt_template_config.input_variables.append(InputVariable(name=variable_name))
+
+    async def render(self, kernel: "Kernel", arguments: "KernelArguments | None" = None) -> str:
+        """Render the prompt template.
+
+        Using the prompt template, replace the variables with their values
+        and execute the functions replacing their reference with the
+        function result.
+
+        Args:
+            kernel ("Kernel"): The kernel to use for functions.
+            arguments ("KernelArguments | None"): The arguments to use for rendering. (Default value = None)
+
+        Returns:
+            str: The prompt template ready to be used for an AI request
+
+        """
+        return await self.render_blocks(self._blocks, kernel, arguments)
+
+    async def render_blocks(
+        self, blocks: list[Block], kernel: "Kernel", arguments: "KernelArguments | None" = None
+    ) -> str:
+        """Given a list of blocks render each block and compose the final result.
+
+        Args:
+            blocks (list[Block]): Template blocks generated by ExtractBlocks
+            kernel ("Kernel"): The kernel to use for functions
+            arguments ("KernelArguments | None"): The arguments to use for rendering (Default value = None)
+
+        Returns:
+            str: The prompt template ready to be used for an AI request
+
+        """
+        from semantic_kernel.template_engine.protocols.code_renderer import CodeRenderer
+        from semantic_kernel.template_engine.protocols.text_renderer import TextRenderer
+
+        logger.debug(f"Rendering list of {len(blocks)} blocks")
+        rendered_blocks: list[str] = []
+        arguments = self._get_trusted_arguments(arguments or KernelArguments())
+        allow_unsafe_function_output = self._get_allow_dangerously_set_function_output()
+        for block in blocks:
+            if isinstance(block, TextRenderer):
+                rendered_blocks.append(block.render(kernel, arguments))
+                continue
+            if isinstance(block, CodeRenderer):
+                try:
+                    rendered = await block.render_code(kernel, arguments)
+                except Exception as exc:
+                    logger.error(f"Error rendering code block: {exc}")
+                    raise TemplateRenderException(f"Error rendering code block: {exc}") from exc
+                rendered_blocks.append(rendered if allow_unsafe_function_output else escape(rendered))
+        prompt = "".join(rendered_blocks)
+        logger.debug(f"Rendered prompt: {prompt}")
+        return prompt

semantic_kernel-1.8.3/semantic_kernel/prompt_template/prompt_template_base.py

@@ -0,0 +1,82 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC, abstractmethod
+from html import escape
+from typing import TYPE_CHECKING
+
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+
+if TYPE_CHECKING:
+    from semantic_kernel.functions.kernel_arguments import KernelArguments
+    from semantic_kernel.kernel import Kernel
+    from semantic_kernel.prompt_template.input_variable import InputVariable
+
+
+class PromptTemplateBase(KernelBaseModel, ABC):
+    """Base class for prompt templates."""
+
+    prompt_template_config: PromptTemplateConfig
+    allow_dangerously_set_content: bool = False
+
+    @abstractmethod
+    async def render(self, kernel: "Kernel", arguments: "KernelArguments") -> str:
+        """Render the prompt template."""
+        pass
+
+    def _get_trusted_arguments(
+        self,
+        arguments: "KernelArguments",
+    ) -> "KernelArguments":
+        """Get the trusted arguments.
+
+        If the prompt template allows unsafe content, then we do not encode the arguments.
+        Otherwise, each argument is checked against the input variables to see if it allowed to be unencoded.
+        Only works on string variables.
+
+        Args:
+            arguments: The kernel arguments
+        """
+        if self.allow_dangerously_set_content:
+            return arguments
+
+        from semantic_kernel.functions.kernel_arguments import KernelArguments
+
+        new_args = KernelArguments(settings=arguments.execution_settings)
+        for name, value in arguments.items():
+            if isinstance(value, str) and self._should_escape(name, self.prompt_template_config.input_variables):
+                new_args[name] = escape(value)
+            else:
+                new_args[name] = value
+        return new_args
+
+    def _get_allow_dangerously_set_function_output(self) -> bool:
+        """Get the allow_dangerously_set_content flag.
+
+        If the prompt template allows unsafe content, then we do not encode the function output,
+        unless explicitly allowed by the prompt template config
+
+        """
+        allow_dangerously_set_content = self.allow_dangerously_set_content
+        if self.prompt_template_config.allow_dangerously_set_content:
+            allow_dangerously_set_content = True
+        return allow_dangerously_set_content
+
+    def _should_escape(self, name: str, input_variables: list["InputVariable"]) -> bool:
+        """Check if the variable should be escaped.
+
+        If the PromptTemplate allows dangerously set content, then the variable will not be escaped,
+        even if the input_variables does specify this.
+
+        Otherwise, it checks the input_variables to see if the variable should be encoded.
+
+        Otherwise, it will encode.
+
+        Args:
+            name: The variable name
+            input_variables: The input variables
+        """
+        for variable in input_variables:
+            if variable.name == name:
+                return not variable.allow_dangerously_set_content
+        return True

semantic_kernel-1.8.3/semantic_kernel/prompt_template/prompt_template_config.py

@@ -0,0 +1,132 @@
+# Copyright (c) Microsoft. All rights reserved.
+import logging
+from typing import TypeVar
+
+from pydantic import Field, field_validator, model_validator
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.const import DEFAULT_SERVICE_NAME
+from semantic_kernel.functions.kernel_parameter_metadata import KernelParameterMetadata
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+from semantic_kernel.prompt_template.const import KERNEL_TEMPLATE_FORMAT_NAME, TEMPLATE_FORMAT_TYPES
+from semantic_kernel.prompt_template.input_variable import InputVariable
+
+PromptExecutionSettingsT = TypeVar("PromptExecutionSettingsT", bound=PromptExecutionSettings)
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class PromptTemplateConfig(KernelBaseModel):
+    """Configuration for a prompt template.
+
+    Args:
+        name: The name of the prompt template.
+        description: The description of the prompt template.
+        template: The template for the prompt.
+        template_format: The format of the template, should be 'semantic-kernel', 'jinja2' or 'handlebars'.
+        input_variables: The input variables for the prompt.
+        allow_dangerously_set_content (bool = False): Allow content without encoding throughout, this overrides
+            the same settings in the prompt template config and input variables.
+            This reverts the behavior to unencoded input.
+        execution_settings: The execution settings for the prompt.
+
+    """
+
+    name: str = ""
+    description: str | None = ""
+    template: str | None = None
+    template_format: TEMPLATE_FORMAT_TYPES = KERNEL_TEMPLATE_FORMAT_NAME
+    input_variables: list[InputVariable] = Field(default_factory=list)
+    allow_dangerously_set_content: bool = False
+    execution_settings: dict[str, PromptExecutionSettings] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def check_input_variables(self):
+        """Verify that input variable default values are string only."""
+        for variable in self.input_variables:
+            if variable.default and not isinstance(variable.default, str):
+                raise TypeError(f"Default value for input variable {variable.name} must be a string.")
+        return self
+
+    @field_validator("execution_settings", mode="before")
+    @classmethod
+    def rewrite_execution_settings(
+        cls,
+        settings: None | (PromptExecutionSettings | list[PromptExecutionSettings] | dict[str, PromptExecutionSettings]),
+    ) -> dict[str, PromptExecutionSettings]:
+        """Rewrite execution settings to a dictionary."""
+        if not settings:
+            return {}
+        if isinstance(settings, PromptExecutionSettings):
+            return {settings.service_id or DEFAULT_SERVICE_NAME: settings}
+        if isinstance(settings, list):
+            return {s.service_id or DEFAULT_SERVICE_NAME: s for s in settings}
+        return settings
+
+    def add_execution_settings(self, settings: PromptExecutionSettings, overwrite: bool = True) -> None:
+        """Add execution settings to the prompt template."""
+        if settings.service_id in self.execution_settings and not overwrite:
+            return
+        self.execution_settings[settings.service_id or DEFAULT_SERVICE_NAME] = settings
+        logger.warning("Execution settings already exist and overwrite is set to False")
+
+    def get_kernel_parameter_metadata(self) -> list[KernelParameterMetadata]:
+        """Get the kernel parameter metadata for the input variables."""
+        return [
+            KernelParameterMetadata(
+                name=variable.name,
+                description=variable.description,
+                default_value=variable.default,
+                type_=variable.json_schema,  # TODO (moonbox3): update to handle complex JSON schemas
+                is_required=variable.is_required,
+            )
+            for variable in self.input_variables
+        ]
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "PromptTemplateConfig":
+        """Create a PromptTemplateConfig instance from a JSON string."""
+        if not json_str:
+            raise ValueError("json_str is empty")
+        try:
+            return cls.model_validate_json(json_str)
+        except Exception as exc:
+            raise ValueError(
+                "Unable to deserialize PromptTemplateConfig from the "
+                f"specified JSON string: {json_str} with exception: {exc}"
+            ) from exc
+
+    @classmethod
+    def restore(
+        cls,
+        name: str,
+        description: str,
+        template: str,
+        template_format: TEMPLATE_FORMAT_TYPES = KERNEL_TEMPLATE_FORMAT_NAME,
+        input_variables: list[InputVariable] = [],
+        execution_settings: dict[str, PromptExecutionSettings] = {},
+        allow_dangerously_set_content: bool = False,
+    ) -> "PromptTemplateConfig":
+        """Restore a PromptTemplateConfig instance from the specified parameters.
+
+        Args:
+            name: The name of the prompt template.
+            description: The description of the prompt template.
+            template: The template for the prompt.
+            template_format: The format of the template, should be 'semantic-kernel', 'jinja2' or 'handlebars'.
+            input_variables: The input variables for the prompt.
+            execution_settings: The execution settings for the prompt.
+            allow_dangerously_set_content: Allow content without encoding.
+
+        Returns:
+            A new PromptTemplateConfig instance.
+        """
+        return cls(
+            name=name,
+            description=description,
+            template=template,
+            template_format=template_format,
+            input_variables=input_variables,
+            execution_settings=execution_settings,
+            allow_dangerously_set_content=allow_dangerously_set_content,
+        )

semantic_kernel-1.8.3/semantic_kernel/prompt_template/utils/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.prompt_template.utils.handlebars_system_helpers import HANDLEBAR_SYSTEM_HELPERS
+from semantic_kernel.prompt_template.utils.jinja2_system_helpers import JINJA2_SYSTEM_HELPERS
+from semantic_kernel.prompt_template.utils.template_function_helpers import create_template_helper_from_function
+
+__all__ = [
+    "HANDLEBAR_SYSTEM_HELPERS",
+    "JINJA2_SYSTEM_HELPERS",
+    "create_template_helper_from_function",
+]

semantic_kernel-1.8.3/semantic_kernel/prompt_template/utils/handlebars_system_helpers.py

@@ -0,0 +1,176 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import json
+import logging
+import re
+from collections.abc import Callable
+from enum import Enum
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+def _messages(this, options, *args, **kwargs):
+    from semantic_kernel.contents.chat_history import ChatHistory
+
+    if not isinstance(this.context["chat_history"], ChatHistory):
+        return ""
+    return this.context["chat_history"].to_prompt()
+
+
+def _message_to_prompt(this, *args, **kwargs):
+    from semantic_kernel.contents.chat_message_content import ChatMessageContent
+
+    if isinstance(this.context, ChatMessageContent):
+        return str(this.context.to_prompt())
+    return str(this.context)
+
+
+def _message(this, options, *args, **kwargs):
+    from semantic_kernel.contents.const import CHAT_MESSAGE_CONTENT_TAG
+
+    # everything in kwargs, goes to <ROOT_KEY_MESSAGE kwargs_key="kwargs_value">
+    # everything in options, goes in between <ROOT_KEY_MESSAGE>options</ROOT_KEY_MESSAGE>
+    start = f"<{CHAT_MESSAGE_CONTENT_TAG}"
+    for key, value in kwargs.items():
+        if isinstance(value, Enum):
+            value = value.value
+        if value is not None:
+            start += f' {key}="{value}"'
+    start += ">"
+    end = f"</{CHAT_MESSAGE_CONTENT_TAG}>"
+    try:
+        content = options["fn"](this)
+    except Exception:  # pragma: no cover
+        content = ""
+    return f"{start}{content}{end}"
+
+
+def _set(this, *args, **kwargs):
+    if "name" in kwargs and "value" in kwargs:
+        this.context[kwargs["name"]] = kwargs["value"]
+    if len(args) == 2 and isinstance(args[0], str):
+        this.context[args[0]] = args[1]
+    return ""
+
+
+def _get(this, *args, **kwargs):
+    if len(args) == 0:
+        return ""
+    return this.context.get(args[0], "")
+
+
+def _array(this, *args, **kwargs):
+    return list(args)
+
+
+def _range(this, *args, **kwargs):
+    args = list(args)
+    for index, arg in enumerate(args):
+        if not isinstance(arg, int):
+            try:
+                args[index] = int(arg)
+            except ValueError:
+                args.pop(index)
+    if len(args) == 1:
+        return list(range(args[0]))
+    if len(args) == 2:
+        return list(range(args[0], args[1]))
+    if len(args) == 3:
+        return list(range(args[0], args[1], args[2]))
+    return []
+
+
+def _concat(this, *args, **kwargs):
+    return "".join([str(value) for value in args])
+
+
+def _or(this, *args, **kwargs):
+    return any(args)
+
+
+def _add(this, *args, **kwargs):
+    return sum([float(value) for value in args])
+
+
+def _subtract(this, *args, **kwargs):
+    return float(args[0]) - sum([float(value) for value in args[1:]])
+
+
+def _equals(this, *args, **kwargs):
+    return args[0] == args[1]
+
+
+def _less_than(this, *args, **kwargs):
+    return float(args[0]) < float(args[1])
+
+
+def _greater_than(this, *args, **kwargs):
+    return float(args[0]) > float(args[1])
+
+
+def _less_than_or_equal(this, *args, **kwargs):
+    return float(args[0]) <= float(args[1])
+
+
+def _greater_than_or_equal(this, *args, **kwargs):
+    return float(args[0]) >= float(args[1])
+
+
+def _json(this, *args, **kwargs):
+    if not args:
+        return ""
+    return json.dumps(args[0])
+
+
+def _double_open(this, *args, **kwargs):
+    return "{{"
+
+
+def _double_close(this, *args, **kwargs):
+    return "}}"
+
+
+def _camel_case(this, *args, **kwargs):
+    return "".join([word.capitalize() for word in args[0].split("_")])
+
+
+def _snake_case(this, *args, **kwargs):
+    arg = args[0]
+    arg = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", arg)
+    arg = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", arg)
+    arg = arg.replace("-", "_")
+    return arg.lower()
+
+
+HANDLEBAR_SYSTEM_HELPERS: dict[str, Callable] = {
+    "set": _set,
+    "get": _get,
+    "array": _array,
+    "range": _range,
+    "concat": _concat,
+    "or": _or,
+    "add": _add,
+    "subtract": _subtract,
+    "equals": _equals,
+    "less_than": _less_than,
+    "lessThan": _less_than,
+    "greater_than": _greater_than,
+    "greaterThan": _greater_than,
+    "less_than_or_equal": _less_than_or_equal,
+    "lessThanOrEqual": _less_than_or_equal,
+    "greater_than_or_equal": _greater_than_or_equal,
+    "greaterThanOrEqual": _greater_than_or_equal,
+    "json": _json,
+    "double_open": _double_open,
+    "doubleOpen": _double_open,
+    "double_close": _double_close,
+    "doubleClose": _double_close,
+    "camel_case": _camel_case,
+    "camelCase": _camel_case,
+    "snake_case": _snake_case,
+    "snakeCase": _snake_case,
+    "message": _message,
+    "message_to_prompt": _message_to_prompt,
+    "messageToPrompt": _message_to_prompt,
+    "messages": _messages,
+}