semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/Plugins/SequentialPlanning/skprompt.txt

@@ -0,0 +1,58 @@
+Create an XML plan step by step, to satisfy the goal given, with the available functions.
+
+[AVAILABLE FUNCTIONS]
+
+{{$available_functions}}
+
+[END AVAILABLE FUNCTIONS]
+
+To create a plan, follow these steps:
+0. The plan should be as short as possible.
+1. From a <goal> create a <plan> as a series of <functions>.
+2. A plan has 'INPUT' available in context variables by default.
+3. Before using any function in a plan, check that it is present in the [AVAILABLE FUNCTIONS] list. If it is not, do not use it.
+4. Only use functions that are required for the given goal.
+5. Append an "END" XML comment at the end of the plan after the final closing </plan> tag.
+6. Always output valid XML that can be parsed by an XML parser.
+7. If a plan cannot be created with the [AVAILABLE FUNCTIONS], return <plan />.
+
+All plans take the form of:
+<plan>
+    <!-- ... reason for taking step ... -->
+    <function.{FullyQualifiedFunctionName} ... />
+    <!-- ... reason for taking step ... -->
+    <function.{FullyQualifiedFunctionName} ... />
+    <!-- ... reason for taking step ... -->
+    <function.{FullyQualifiedFunctionName} ... />
+    (... etc ...)
+</plan>
+<!-- END -->
+
+To call a function, follow these steps:
+1. A function has one or more named parameters and a single 'output' which are all strings. Parameter values should be xml escaped.
+2. To save an 'output' from a <function>, to pass into a future <function>, use <function.{FullyQualifiedFunctionName} ... setContextVariable="<UNIQUE_VARIABLE_KEY>"/>
+3. To save an 'output' from a <function>, to return as part of a plan result, use <function.{FullyQualifiedFunctionName} ... appendToResult="RESULT__<UNIQUE_RESULT_KEY>"/>
+4. Use a '$' to reference a context variable in a parameter, e.g. when `INPUT='world'` the parameter 'Hello $INPUT' will evaluate to `Hello world`.
+5. Functions do not have access to the context variables of other functions. Do not attempt to use context variables as arrays or objects. Instead, use available functions to extract specific elements or properties from context variables.
+
+DO NOT DO THIS, THE PARAMETER VALUE IS NOT XML ESCAPED:
+<function.Plugin-Name4 input="$SOME_PREVIOUS_OUTPUT" parameter_name="some value with a <!-- 'comment' in it-->"/>
+
+DO NOT DO THIS, THE PARAMETER VALUE IS ATTEMPTING TO USE A CONTEXT VARIABLE AS AN ARRAY/OBJECT:
+<function.Plugin-CallFunction input="$OTHER_OUTPUT[1]"/>
+
+DO NOT DO THIS, THE FUNCTION NAME IS NOT A FULLY QUALIFIED FUNCTION NAME:
+<function.CallFunction input="world"/>
+
+Here is a valid example of how to call a function "_plugin-Function_Name" with a single input and save its output:
+<function._plugin-Function_Name input="this is my input" setContextVariable="SOME_KEY"/>
+
+Here is a valid example of how to call a function "Plugin-FunctionName2" with a single input and return its output as part of the plan result:
+<function.Plugin-FunctionName2 input="Hello $INPUT" appendToResult="RESULT__FINAL_ANSWER"/>
+
+Here is a valid example of how to call a function "Name3" with multiple inputs:
+<function.Plugin-Name3 input="$SOME_PREVIOUS_OUTPUT" parameter_name="some value with a &lt;!-- &apos;comment&apos; in it--&gt;"/>
+
+Begin!
+
+<goal>{{$input}}</goal>

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.planners.sequential_planner.sequential_planner import (
+    SequentialPlanner,
+)
+
+__all__ = [
+    "SequentialPlanner",
+]

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/sequential_planner.py

@@ -0,0 +1,138 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import os
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.const import DEFAULT_SERVICE_NAME, METADATA_EXCEPTION_KEY
+from semantic_kernel.exceptions import PlannerCreatePlanError, PlannerException, PlannerInvalidGoalError
+from semantic_kernel.functions.function_result import FunctionResult
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.functions.kernel_function import KernelFunction
+from semantic_kernel.kernel import Kernel
+from semantic_kernel.planners.plan import Plan
+from semantic_kernel.planners.sequential_planner.sequential_planner_config import SequentialPlannerConfig
+from semantic_kernel.planners.sequential_planner.sequential_planner_extensions import SequentialPlannerKernelExtension
+from semantic_kernel.planners.sequential_planner.sequential_planner_parser import SequentialPlanParser
+from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+
+SEQUENTIAL_PLANNER_DEFAULT_DESCRIPTION = (
+    "Given a request or command or goal generate a step by step plan to "
+    "fulfill the request using functions. This ability is also known as decision making and function flow"
+)
+
+CUR_DIR = os.path.dirname(os.path.realpath(__file__))
+PROMPT_CONFIG_FILE_PATH = os.path.join(CUR_DIR, "Plugins/SequentialPlanning/config.json")
+PROMPT_TEMPLATE_FILE_PATH = os.path.join(CUR_DIR, "Plugins/SequentialPlanning/skprompt.txt")
+
+
+def read_file(file_path: str) -> str:
+    """Reads the content of a file."""
+    with open(file_path) as file:
+        return file.read()
+
+
+class SequentialPlanner:
+    """Sequential planner class."""
+
+    RESTRICTED_PLUGIN_NAME = "SequentialPlanner_Excluded"
+
+    config: SequentialPlannerConfig
+    _kernel: "Kernel"
+    _arguments: "KernelArguments"
+    _function_flow_function: "KernelFunction"
+
+    def __init__(
+        self,
+        kernel: Kernel,
+        service_id: str,
+        config: SequentialPlannerConfig = None,
+        prompt: str | None = None,
+    ) -> None:
+        """Initializes a new instance of the SequentialPlanner class.
+
+        Args:
+            kernel (Kernel): The kernel instance to use for planning
+            service_id (str): The service id to use to get the AI service
+            config (SequentialPlannerConfig, optional): The configuration to use for planning. Defaults to None.
+            prompt (str, optional): The prompt to use for planning. Defaults to None.
+        """
+        self.config = config or SequentialPlannerConfig()
+
+        self.config.excluded_plugins.append(self.RESTRICTED_PLUGIN_NAME)
+
+        self._kernel = kernel
+        self._arguments = KernelArguments()
+        self._function_flow_function = self._init_flow_function(prompt, service_id)
+
+    def _init_flow_function(self, prompt: str, service_id: str) -> "KernelFunction":
+        prompt_config = PromptTemplateConfig.from_json(read_file(PROMPT_CONFIG_FILE_PATH))
+        prompt_template = prompt or read_file(PROMPT_TEMPLATE_FILE_PATH)
+        if service_id in prompt_config.execution_settings:
+            prompt_config.execution_settings[service_id].extension_data["max_tokens"] = self.config.max_tokens
+        elif DEFAULT_SERVICE_NAME in prompt_config.execution_settings:
+            prompt_config.execution_settings[DEFAULT_SERVICE_NAME].extension_data["max_tokens"] = self.config.max_tokens
+        else:
+            prompt_config.execution_settings[service_id] = PromptExecutionSettings(
+                service_id=service_id, max_tokens=self.config.max_tokens
+            )
+        prompt_config.template = prompt_template
+
+        # if a service_id is provided, use it instead of the default
+        if (
+            service_id
+            and service_id not in prompt_config.execution_settings
+            and DEFAULT_SERVICE_NAME in prompt_config.execution_settings
+        ):
+            settings = prompt_config.execution_settings.pop(DEFAULT_SERVICE_NAME)
+            prompt_config.execution_settings[service_id] = settings
+
+        return self._kernel.add_function(
+            plugin_name=self.RESTRICTED_PLUGIN_NAME,
+            function_name=self.RESTRICTED_PLUGIN_NAME,
+            prompt_template_config=prompt_config,
+        )
+
+    async def create_plan(self, goal: str) -> Plan:
+        """Create a plan for the specified goal."""
+        if len(goal) == 0:
+            raise PlannerInvalidGoalError("The goal specified is empty")
+
+        relevant_function_manual = await SequentialPlannerKernelExtension.get_functions_manual(
+            self._kernel, self._arguments, goal, self.config
+        )
+        self._arguments["available_functions"] = relevant_function_manual
+        self._arguments["input"] = goal
+
+        plan_result = await self._function_flow_function.invoke(self._kernel, self._arguments)
+
+        if isinstance(plan_result, FunctionResult) and METADATA_EXCEPTION_KEY in plan_result.metadata:
+            raise PlannerCreatePlanError(
+                f"Error creating plan for goal: {plan_result.metadata['exception']}",
+            ) from plan_result.metadata[METADATA_EXCEPTION_KEY]
+
+        plan_result_string = str(plan_result).strip()
+
+        try:
+            plan = SequentialPlanParser.to_plan_from_xml(
+                xml_string=plan_result_string,
+                goal=goal,
+                kernel=self._kernel,
+                get_plugin_function=self.config.get_plugin_function,
+                allow_missing_functions=self.config.allow_missing_functions,
+            )
+
+            if len(plan._steps) == 0:
+                raise PlannerCreatePlanError(
+                    "Not possible to create plan for goal with available functions.\n",
+                    f"Goal:{goal}\nFunctions:\n{relevant_function_manual}",
+                )
+
+            return plan
+
+        except PlannerException as e:
+            raise e
+        except Exception as e:
+            raise PlannerException(
+                "Unknown error creating plan",
+                e,
+            ) from e

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/sequential_planner_config.py

@@ -0,0 +1,30 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from collections.abc import Callable
+
+
+class SequentialPlannerConfig:
+    """Configuration for the SequentialPlanner."""
+
+    def __init__(
+        self,
+        relevancy_threshold: float | None = None,
+        max_relevant_functions: int = 100,
+        excluded_plugins: list[str] | None = None,
+        excluded_functions: list[str] | None = None,
+        included_functions: list[str] | None = None,
+        max_tokens: int = 1024,
+        allow_missing_functions: bool = False,
+        get_available_functions: Callable | None = None,
+        get_plugin_function: Callable | None = None,
+    ):
+        """Initializes a new instance of the SequentialPlannerConfig class."""
+        self.relevancy_threshold: float = relevancy_threshold
+        self.max_relevant_functions: int = max_relevant_functions
+        self.excluded_plugins: list[str] = excluded_plugins or []
+        self.excluded_functions: list[str] = excluded_functions or []
+        self.included_functions: list[str] = included_functions or []
+        self.max_tokens: int = max_tokens
+        self.allow_missing_functions: bool = allow_missing_functions
+        self.get_available_functions = get_available_functions
+        self.get_plugin_function = get_plugin_function

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/sequential_planner_extensions.py

@@ -0,0 +1,124 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.functions.kernel_function_metadata import KernelFunctionMetadata
+from semantic_kernel.kernel import Kernel
+from semantic_kernel.memory.memory_query_result import MemoryQueryResult
+from semantic_kernel.planners.sequential_planner.sequential_planner_config import SequentialPlannerConfig
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class SequentialPlannerFunctionExtension:
+    """Function extension for the sequential planner."""
+
+    @staticmethod
+    def to_manual_string(function: KernelFunctionMetadata):
+        """Convert the function to a manual string."""
+        inputs = [
+            f"  - {parameter.name}: {parameter.description}"
+            + (f" (default value: {parameter.default_value})" if parameter.default_value else "")
+            for parameter in function.parameters
+        ]
+        inputs = "\n".join(inputs)
+        return f"{function.fully_qualified_name}:\n  description: {function.description}\n  inputs:\n  {inputs}"
+
+    @staticmethod
+    def to_embedding_string(function: KernelFunctionMetadata):
+        """Convert the function to an embedding string."""
+        inputs = "\n".join([f"    - {parameter.name}: {parameter.description}" for parameter in function.parameters])
+        return f"{function.name}:\n  description: {function.description}\n  inputs:\n{inputs}"
+
+
+class SequentialPlannerKernelExtension:
+    """Kernel extension for the sequential planner."""
+
+    PLANNER_MEMORY_COLLECTION_NAME = " Planning.KernelFunctionManual"
+    PLAN_KERNEL_FUNCTIONS_ARE_REMEMBERED = "Planning.KernelFunctionsAreRemembered"
+
+    @staticmethod
+    async def get_functions_manual(
+        kernel: "Kernel",
+        arguments: KernelArguments,
+        semantic_query: str | None = None,
+        config: SequentialPlannerConfig = None,
+    ) -> str:
+        """Get the functions manual."""
+        config = config or SequentialPlannerConfig()
+
+        if config.get_available_functions is None:
+            functions = await SequentialPlannerKernelExtension.get_available_functions(
+                kernel, arguments, config, semantic_query
+            )
+        else:
+            functions = await config.get_available_functions(config, semantic_query)
+
+        return "\n\n".join([SequentialPlannerFunctionExtension.to_manual_string(func) for func in functions])
+
+    @staticmethod
+    async def get_available_functions(
+        kernel: Kernel,
+        arguments: KernelArguments,
+        config: SequentialPlannerConfig,
+        semantic_query: str | None = None,
+    ):
+        """Get the available functions based on the semantic query."""
+        excluded_plugins = config.excluded_plugins or []
+        excluded_functions = config.excluded_functions or []
+        included_functions = config.included_functions or []
+
+        available_functions = [
+            func
+            for func in kernel.get_list_of_function_metadata({"excluded_plugins": excluded_plugins})
+            if func.name not in excluded_functions
+        ]
+
+        if semantic_query is None or config.relevancy_threshold is None:
+            # If no semantic query is provided, return all available functions.
+            # If a Memory provider has not been registered, return all available functions.
+            return available_functions
+
+        # Add functions that were found in the search results.
+        relevant_functions = await SequentialPlannerKernelExtension.get_relevant_functions(
+            kernel,
+            available_functions,
+        )
+
+        # Add any missing functions that were included but not found in the search results.
+        missing_functions = [
+            func for func in included_functions if func not in [func.name for func in relevant_functions]
+        ]
+
+        relevant_functions += [func for func in available_functions if func.name in missing_functions]
+
+        return sorted(relevant_functions, key=lambda x: (x.plugin_name, x.name))
+
+    @staticmethod
+    async def get_relevant_functions(
+        kernel: Kernel,
+        available_functions: list[KernelFunctionMetadata],
+        memories: list[MemoryQueryResult] | None = None,
+    ) -> list[KernelFunctionMetadata]:
+        """Get relevant functions from the memories."""
+        relevant_functions = []
+        # TODO (eavanvalkenburg): cancellation
+        # https://github.com/microsoft/semantic-kernel/issues/5668
+        if memories is None:
+            return relevant_functions
+        for memory_entry in memories:
+            function = next(
+                (func for func in available_functions if func.fully_qualified_name == memory_entry.id),
+                None,
+            )
+            if function is not None:
+                logger.debug(
+                    "Found relevant function. Relevance Score: {}, Function: {}".format(
+                        memory_entry.relevance,
+                        function.fully_qualified_name,
+                    )
+                )
+                relevant_functions.append(function)
+
+        return relevant_functions

semantic_kernel-1.8.3/semantic_kernel/planners/sequential_planner/sequential_planner_parser.py

@@ -0,0 +1,120 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import re
+from collections.abc import Callable
+
+from defusedxml import ElementTree as ET
+
+from semantic_kernel.exceptions import PlannerInvalidPlanError
+from semantic_kernel.exceptions.kernel_exceptions import KernelFunctionNotFoundError, KernelPluginNotFoundError
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.functions.kernel_function import KernelFunction
+from semantic_kernel.kernel import Kernel
+from semantic_kernel.planners.plan import Plan
+
+# Constants
+GOAL_TAG = "goal"
+SOLUTION_TAG = "plan"
+FUNCTION_TAG = "function."
+SET_CONTEXT_VARIABLE_TAG = "setContextVariable"
+APPEND_TO_RESULT_TAG = "appendToResult"
+
+
+class SequentialPlanParser:
+    """Parser for Sequential planners."""
+
+    @staticmethod
+    def to_plan_from_xml(
+        xml_string: str,
+        goal: str,
+        kernel: Kernel,
+        get_plugin_function: Callable[[str, str], KernelFunction | None] | None = None,
+        allow_missing_functions: bool = False,
+    ):
+        """Convert an xml string to a plan."""
+        xml_string = "<xml>" + xml_string + "</xml>"
+        try:
+            xml_doc = ET.fromstring(xml_string)
+        except ET.ParseError:
+            # Attempt to parse <plan> out of it
+            plan_regex = re.compile(r"<plan\b[^>]*>(.*?)</plan>", re.DOTALL)
+            match = plan_regex.search(xml_string)
+
+            if match:
+                plan_xml = match.group(0)
+                try:
+                    xml_doc = ET.fromstring("<xml>" + plan_xml + "</xml>")
+                except ET.ParseError:
+                    raise PlannerInvalidPlanError(f"Failed to parse plan xml strings: '{xml_string}' or '{plan_xml}'")
+            else:
+                raise PlannerInvalidPlanError(f"Failed to parse plan xml string: '{xml_string}'")
+
+        solution = xml_doc.findall(".//" + SOLUTION_TAG)
+
+        plan = Plan.from_goal(goal)
+        for solution_node in solution:
+            for child_node in solution_node:
+                if (
+                    child_node.tag == "#text"
+                    or child_node.tag == "#comment"
+                    or (not child_node.tag.startswith(FUNCTION_TAG))
+                ):
+                    continue
+
+                plugin_function_name = child_node.tag.split(FUNCTION_TAG)[1]
+                if get_plugin_function:
+                    try:
+                        func = get_plugin_function(
+                            *SequentialPlanParser.get_plugin_function_names(plugin_function_name)
+                        )
+                    except Exception as exc:
+                        if allow_missing_functions:
+                            plan.add_steps([Plan.from_goal(plugin_function_name)])
+                            continue
+                        raise PlannerInvalidPlanError(f"Failed to find function '{plugin_function_name}'.") from exc
+                else:
+                    try:
+                        func = kernel.get_function_from_fully_qualified_function_name(plugin_function_name)
+                    except (KernelFunctionNotFoundError, KernelPluginNotFoundError) as exc:
+                        if allow_missing_functions:
+                            plan.add_steps([Plan.from_goal(plugin_function_name)])
+                            continue
+                        raise PlannerInvalidPlanError(
+                            f"Failed to find function '{plugin_function_name}'.",
+                        ) from exc
+
+                plan_step = Plan.from_function(func)
+
+                function_variables = KernelArguments()
+                function_outputs = []
+                function_results = []
+
+                for p in func.metadata.parameters:
+                    function_variables[p.name] = p.default_value
+
+                for attr in child_node.attrib:
+                    if attr == SET_CONTEXT_VARIABLE_TAG:
+                        function_outputs.append(child_node.attrib[attr])
+                    elif attr == APPEND_TO_RESULT_TAG:
+                        function_outputs.append(child_node.attrib[attr])
+                        function_results.append(child_node.attrib[attr])
+                    else:
+                        function_variables[attr] = child_node.attrib[attr]
+
+                plan_step._outputs = function_outputs
+                plan_step._parameters = function_variables
+
+                for result in function_results:
+                    plan._outputs.append(result)
+
+                plan.add_steps([plan_step])
+
+        return plan
+
+    @staticmethod
+    def get_plugin_function_names(plugin_function_name: str) -> tuple[str, str]:
+        """Get the plugin and function names from the plugin function name."""
+        plugin_function_name_parts = plugin_function_name.split("-")
+        plugin_name = plugin_function_name_parts[0] if len(plugin_function_name_parts) > 0 else ""
+        function_name = plugin_function_name_parts[1] if len(plugin_function_name_parts) > 1 else plugin_function_name
+        return plugin_name, function_name

semantic_kernel-1.8.3/semantic_kernel/prompt_template/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.prompt_template.handlebars_prompt_template import HandlebarsPromptTemplate
+from semantic_kernel.prompt_template.input_variable import InputVariable
+from semantic_kernel.prompt_template.jinja2_prompt_template import Jinja2PromptTemplate
+from semantic_kernel.prompt_template.kernel_prompt_template import KernelPromptTemplate
+from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig
+
+__all__ = [
+    "HandlebarsPromptTemplate",
+    "InputVariable",
+    "Jinja2PromptTemplate",
+    "KernelPromptTemplate",
+    "PromptTemplateConfig",
+]

semantic_kernel-1.8.3/semantic_kernel/prompt_template/const.py

@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Literal, get_args
+
+KERNEL_TEMPLATE_FORMAT_NAME_TYPE = Literal["semantic-kernel"]
+KERNEL_TEMPLATE_FORMAT_NAME: KERNEL_TEMPLATE_FORMAT_NAME_TYPE = get_args(KERNEL_TEMPLATE_FORMAT_NAME_TYPE)[0]
+HANDLEBARS_TEMPLATE_FORMAT_NAME_TYPE = Literal["handlebars"]
+HANDLEBARS_TEMPLATE_FORMAT_NAME: HANDLEBARS_TEMPLATE_FORMAT_NAME_TYPE = get_args(HANDLEBARS_TEMPLATE_FORMAT_NAME_TYPE)[
+    0
+]
+JINJA2_TEMPLATE_FORMAT_NAME_TYPE = Literal["jinja2"]
+JINJA2_TEMPLATE_FORMAT_NAME: JINJA2_TEMPLATE_FORMAT_NAME_TYPE = get_args(JINJA2_TEMPLATE_FORMAT_NAME_TYPE)[0]
+
+TEMPLATE_FORMAT_TYPES = Literal[
+    KERNEL_TEMPLATE_FORMAT_NAME_TYPE, HANDLEBARS_TEMPLATE_FORMAT_NAME_TYPE, JINJA2_TEMPLATE_FORMAT_NAME_TYPE
+]

semantic_kernel-1.8.3/semantic_kernel/prompt_template/handlebars_prompt_template.py

@@ -0,0 +1,115 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional
+
+from pybars import Compiler, PybarsError
+from pydantic import PrivateAttr, field_validator
+
+from semantic_kernel.exceptions import HandlebarsTemplateRenderException, HandlebarsTemplateSyntaxError
+from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.prompt_template.const import HANDLEBARS_TEMPLATE_FORMAT_NAME
+from semantic_kernel.prompt_template.prompt_template_base import PromptTemplateBase
+from semantic_kernel.prompt_template.utils import HANDLEBAR_SYSTEM_HELPERS, create_template_helper_from_function
+
+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 HandlebarsPromptTemplate(PromptTemplateBase):
+    """Create a Handlebars prompt template.
+
+    Handlebars are parsed as a whole and therefore do not have variables that can be extracted,
+    also with handlebars there is no distinction in syntax between a variable and a value,
+    a value that is encountered is tried to resolve with the arguments and the functions,
+    if not found, the literal value is returned.
+
+    Args:
+        prompt_template_config (PromptTemplateConfig): The prompt template configuration
+            This is checked if the template format is 'handlebars'
+        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 is not 'handlebars'
+        HandlebarsTemplateSyntaxError: If the handlebars template has a syntax error
+    """
+
+    _template_compiler: Any = PrivateAttr()
+
+    @field_validator("prompt_template_config")
+    @classmethod
+    def validate_template_format(cls, v: "PromptTemplateConfig") -> "PromptTemplateConfig":
+        """Validate the template format."""
+        if v.template_format != HANDLEBARS_TEMPLATE_FORMAT_NAME:
+            raise ValueError(f"Invalid prompt template format: {v.template_format}. Expected: handlebars")
+        return v
+
+    def model_post_init(self, __context: Any) -> None:
+        """Post init model."""
+        if not self.prompt_template_config.template:
+            self._template_compiler = None
+            return
+        try:
+            self._template_compiler = Compiler().compile(self.prompt_template_config.template)
+        except PybarsError as e:
+            logger.error(f"Invalid handlebars template: {self.prompt_template_config.template}")
+            raise HandlebarsTemplateSyntaxError(
+                f"Invalid handlebars template: {self.prompt_template_config.template}"
+            ) from e
+
+    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._template_compiler:
+            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]] = {}
+        for plugin in kernel.plugins.values():
+            helpers.update(
+                {
+                    function.fully_qualified_name: create_template_helper_from_function(
+                        function,
+                        kernel,
+                        arguments,
+                        self.prompt_template_config.template_format,
+                        allow_unsafe_function_output,
+                    )
+                    for function in plugin
+                }
+            )
+        helpers.update(HANDLEBAR_SYSTEM_HELPERS)
+
+        try:
+            return self._template_compiler(
+                arguments,
+                helpers=helpers,
+            )
+        except PybarsError as exc:
+            logger.error(
+                f"Error rendering prompt template: {self.prompt_template_config.template} with arguments: {arguments}"
+            )
+            raise HandlebarsTemplateRenderException(
+                f"Error rendering prompt template: {self.prompt_template_config.template} "
+                f"with arguments: {arguments}: error: {exc}"
+            ) from exc

semantic_kernel-1.8.3/semantic_kernel/prompt_template/input_variable.py

@@ -0,0 +1,26 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Any
+
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+
+
+class InputVariable(KernelBaseModel):
+    """Input variable for a prompt template.
+
+    Args:
+        name: The name of the input variable.
+        description: The description of the input variable.
+        default: The default value of the input variable.
+        is_required: Whether the input variable is required.
+        json_schema: The JSON schema for the input variable.
+        allow_dangerously_set_content: Allow content without encoding, this controls
+            if this variable is encoded before use, default is False.
+    """
+
+    name: str
+    description: str | None = ""
+    default: Any | None = ""
+    is_required: bool | None = True
+    json_schema: str | None = ""
+    allow_dangerously_set_content: bool = False