Added more groups of prompt template.

app/config.py

@@ -1,13 +1,21 @@
 # config.py
 from confz import BaseConfig
-from pydantic import BaseModel, Extra
-from typing import Optional
+from pydantic import BaseModel
+from typing import Optional, Dict, List
+
+class RoleMessage(BaseModel):
+    role: str
+    message: str
 
 class LLMConfig(BaseModel):
     type: str
 
     class Config:
-        extra = Extra.allow
+        extra = 'allow'
+
+class PromptGroup(BaseModel):
+    class Config:
+        extra = 'allow'
 
 class MetaPromptConfig(BaseConfig):
     llms: Optional[dict[str, LLMConfig]]
@@ -19,4 +27,8 @@ class MetaPromptConfig(BaseConfig):
     allow_flagging: Optional[bool] = False
     verbose: Optional[bool] = False
     max_output_age: Optional[int] = 3
-    max_output_age_max: Optional[int] = 8
+    max_output_age_max: Optional[int] = 8
+    prompt_templates: Optional[Dict[str, Dict[str, List[RoleMessage]]]] = None
+
+    class Config:
+        extra = 'allow'

app/gradio_meta_prompt.py

@@ -9,14 +9,36 @@ from gradio import CSVLogger, Button, utils
 from gradio.flagging import FlagMethod
 from gradio_client import utils as client_utils
 from confz import BaseConfig, CLArgSource, EnvSource, FileSource
-from app.config import MetaPromptConfig
+from app.config import MetaPromptConfig, RoleMessage
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_openai import ChatOpenAI
 from meta_prompt import *
 from pythonjsonlogger import jsonlogger
 import pprint
+from langchain_core.prompts import ChatPromptTemplate
+from typing import Optional, Dict, List
+
+def prompt_templates_confz2langchain(prompt_templates: Dict[str, Dict[str, List[RoleMessage]]]) -> Dict[str, ChatPromptTemplate]:
+    """
+    Convert a dictionary of prompt templates from the configuration format to the language chain format.
+
+    This function takes a dictionary of prompt templates in the configuration format and converts them to the language chain format.
+    Each prompt template is converted to a ChatPromptTemplate object, which is then stored in a new dictionary with the same keys.
 
+    Args:
+        prompt_templates (Dict[str, Dict[str, List[RoleMessage]]]): A dictionary of prompt templates in the configuration format.
+
+    Returns:
+        Dict[str, ChatPromptTemplate]: A dictionary of prompt templates in the language chain format.
+    """
+    return {
+        node: ChatPromptTemplate.from_messages([
+            (role_message.role, role_message.message)
+            for role_message in role_messages
+        ])
+        for node, role_messages in prompt_templates.items()
+    }
 
 class SimplifiedCSVLogger(CSVLogger):
     """
@@ -260,7 +282,11 @@ def evaluate_system_message(system_message, user_message,
         raise gr.Error(f"Error: {e}")
 
 
-def process_message(user_message, expected_output, acceptance_criteria, initial_system_message, recursion_limit: int, max_output_age: int, llms: Union[BaseLanguageModel, Dict[str, BaseLanguageModel]]):
+def process_message(user_message: str, expected_output: str,
+                    acceptance_criteria: str, initial_system_message: str,
+                    recursion_limit: int, max_output_age: int,
+                    llms: Union[BaseLanguageModel, Dict[str, BaseLanguageModel]],
+                    prompt_template_group: Optional[str] = None) -> tuple:
     """
     Process a user message by executing the MetaPromptGraph with provided language models and input state.
     This function sets up the initial state of the conversation, logs the execution if verbose mode is enabled,
@@ -298,7 +324,11 @@ def process_message(user_message, expected_output, acceptance_criteria, initial_
             '%(asctime)s %(name)s %(levelname)s %(message)s'))
         logger.addHandler(log_handler)
 
-    meta_prompt_graph = MetaPromptGraph(llms=llms, verbose=config.verbose, logger=logger)
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(config.prompt_templates[prompt_template_group])
+    meta_prompt_graph = MetaPromptGraph(llms=llms, prompts=prompt_templates,
+                                        verbose=config.verbose, logger=logger)
     try:
         output_state = meta_prompt_graph(input_state, recursion_limit=recursion_limit)
     except Exception as e:
@@ -360,19 +390,22 @@ def initialize_llm(model_name: str, model_config: Optional[Dict[str, Any]] = Non
         raise NotImplementedError(f"Unrecognized type configured for the language model: {model_type}")
 
 
-def process_message_with_single_llm(user_message, expected_output, acceptance_criteria, initial_system_message,
+def process_message_with_single_llm(user_message: str, expected_output: str,
+                                    acceptance_criteria: str, initial_system_message: str,
                                     recursion_limit: int, max_output_age: int,
-                                    model_name: str):
+                                    model_name: str, prompt_template_group: Optional[str] = None) -> tuple:
     """
     Process a user message using a single language model.
 
-    This function initializes the specified language model and then uses it to process the user's
-    message along with other provided input parameters such as expected output, acceptance criteria,
-    initial system message, recursion limit, and max output age. The result is obtained by calling
-    the `process_message` function with this single language model.
+    This function initializes a language model based on the provided model name and 
+    uses it to process the user's message. The function takes in additional parameters 
+    such as the user's message, expected output, acceptance criteria, initial system 
+    message, recursion limit, and max output age. It then calls the `process_message` 
+    function with the initialized language model to obtain the best system message, 
+    output, analysis, and chat log.
 
-    Args:
-        user_message (str): The user's input message to be processed by the language model(s).
+    Parameters:
+    user_message (str): The user's input message to be processed by the language model.
         expected_output (str): The anticipated response or outcome from the language model based on the user's message.
         acceptance_criteria (str): Criteria that determines whether the output is acceptable or not.
         initial_system_message (str): Initial instruction given to the language model before processing the user's message.
@@ -380,6 +413,7 @@ def process_message_with_single_llm(user_message, expected_output, acceptance_cr
         max_output_age (int): The maximum age of output messages that should be considered in the conversation history.
         model_name (str): The name of the language model to initialize and use for processing the user's message.
             This should correspond to a key in the 'llms' section of the application's configuration.
+        prompt_template_group (Optional[str], optional): The name of the prompt template group to use for processing the user's message. Defaults to None.
 
     Returns:
         tuple: A tuple containing the best system message, output, analysis, and chat log in JSON format.
@@ -390,12 +424,14 @@ def process_message_with_single_llm(user_message, expected_output, acceptance_cr
     """
     llm = initialize_llm(model_name)
     return process_message(user_message, expected_output, acceptance_criteria, initial_system_message,
-                           recursion_limit, max_output_age, llm)
+                           recursion_limit, max_output_age, llm, prompt_template_group)
 
 
-def process_message_with_2_llms(user_message, expected_output, acceptance_criteria, initial_system_message,
+def process_message_with_2_llms(user_message: str, expected_output: str,
+                                acceptance_criteria: str, initial_system_message: str,
                                 recursion_limit: int, max_output_age: int,
-                                optimizer_model_name: str, executor_model_name: str):
+                                optimizer_model_name: str, executor_model_name: str,
+                                prompt_template_group: Optional[str] = None) -> tuple:
     """
     Process a user message using two language models - one for optimization and another for execution.
 
@@ -416,6 +452,7 @@ def process_message_with_2_llms(user_message, expected_output, acceptance_criter
             This should correspond to a key in the 'llms' section of the application's configuration.
         executor_model_name (str): The name of the language model to initialize and use for execution tasks like running code or providing final outputs.
             This should correspond to a key in the 'llms' section of the application's configuration.
+        prompt_template_group (Optional[str], optional): The name of the prompt template group to use for processing the user's message. Defaults to None.
 
     Returns:
         tuple: A tuple containing the best system message, output, analysis, and chat log in JSON format.
@@ -435,46 +472,20 @@ def process_message_with_2_llms(user_message, expected_output, acceptance_criter
         NODE_PROMPT_SUGGESTER: optimizer_model
     }
     return process_message(user_message, expected_output, acceptance_criteria, initial_system_message,
-                           recursion_limit, max_output_age, llms)
+                           recursion_limit, max_output_age, llms, prompt_template_group)
 
 
-def process_message_with_expert_llms(user_message, expected_output, acceptance_criteria, initial_system_message,
+def process_message_with_expert_llms(user_message: str, expected_output: str,
+                                     acceptance_criteria: str, initial_system_message: str,
                                      recursion_limit: int, max_output_age: int,
                                      initial_developer_model_name: str, initial_developer_temperature: float,
                                      developer_model_name: str, developer_temperature: float,
                                      executor_model_name: str, executor_temperature: float,
                                      output_history_analyzer_model_name: str, output_history_analyzer_temperature: float,
                                      analyzer_model_name: str, analyzer_temperature: float,
-                                     suggester_model_name: str, suggester_temperature: float):
-    """
-    Process a user message using multiple expert language models.
-
-    This function initializes six expert language models based on their names and uses them to process the user's message
-    along with other provided input parameters such as expected output, acceptance criteria, initial system message, 
-    recursion limit, and max output age. The result is obtained by calling the `process_message` function with a dictionary 
-    of language models where each node uses a specific language model.
-
-    Args:
-        user_message (str): The user's input message to be processed by the language models.
-        expected_output (str): The anticipated response or outcome from the language models based on the user's message.
-        acceptance_criteria (str): Criteria that determines whether the output is acceptable or not.
-        initial_system_message (str): Initial instruction given to the language models before processing the user's message.
-        recursion_limit (int): The maximum number of times the MetaPromptGraph can call itself recursively.
-        max_output_age (int): The maximum age of output messages that should be considered in the conversation history.
-        initial_developer_model_name (str): The name of the language model to initialize and use for the initial developer node.
-        developer_model_name (str): The name of the language model to initialize and use for the developer node.
-        executor_model_name (str): The name of the language model to initialize and use for the executor node.
-        output_history_analyzer_model_name (str): The name of the language model to initialize and use for the output history analyzer node.
-        analyzer_model_name (str): The name of the language model to initialize and use for the analyzer node.
-        suggester_model_name (str): The name of the language model to initialize and use for the suggester node.
+                                     suggester_model_name: str, suggester_temperature: float,
+                                     prompt_template_group: Optional[str] = None) -> tuple:
 
-    Returns:
-        tuple: A tuple containing the best system message, output, analysis, and chat log in JSON format.
-            - best_system_message (str): The system message that resulted in the most appropriate response based on the acceptance criteria.
-            - best_output (str): The output generated by the language models that best meets the expected outcome and acceptance criteria.
-            - analysis (str): An analysis of how well the generated output matches the expected output and acceptance criteria.
-            - chat_log (list): A list containing JSON objects representing the conversation log, with each object containing a timestamp, logger name, levelname, and message.
-    """
     llms = {
         NODE_PROMPT_INITIAL_DEVELOPER: initialize_llm(initial_developer_model_name, {"temperature": initial_developer_temperature}),
         NODE_PROMPT_DEVELOPER: initialize_llm(developer_model_name, {"temperature": developer_temperature}),
@@ -484,7 +495,7 @@ def process_message_with_expert_llms(user_message, expected_output, acceptance_c
         NODE_PROMPT_SUGGESTER: initialize_llm(suggester_model_name, {"temperature": suggester_temperature})
     }
     return process_message(user_message, expected_output, acceptance_criteria, initial_system_message,
-                           recursion_limit, max_output_age, llms)
+                           recursion_limit, max_output_age, llms, prompt_template_group=prompt_template_group)
 
 
 class FileConfig(BaseConfig):
@@ -520,7 +531,7 @@ with gr.Blocks(title='Meta Prompt') as demo:
             expected_output_input = gr.Textbox(
                 label="Expected Output", show_copy_button=True)
             acceptance_criteria_input = gr.Textbox(
-                label="Acceptance Criteria", show_copy_button=True)
+                label="Acceptance Criteria (Compared with Expected Output [EO])", show_copy_button=True)
             initial_system_message_input = gr.Textbox(
                 label="Initial System Message", show_copy_button=True, value="")
             evaluate_initial_system_message_button = gr.Button(
@@ -531,6 +542,11 @@ with gr.Blocks(title='Meta Prompt') as demo:
             max_output_age = gr.Number(
                 label="Max Output Age", value=config.max_output_age,
                 precision=0, minimum=1, maximum=config.max_output_age_max, step=1)
+            prompt_template_group = gr.Dropdown(
+                label="Prompt Template Group",
+                choices=list(config.prompt_templates.keys()),
+                value=list(config.prompt_templates.keys())[0],
+            )
             with gr.Row():
                 with gr.Tabs():
                     with gr.Tab('Simple') as simple_llm_tab:
@@ -713,7 +729,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
             initial_system_message_input,
             recursion_limit_input,
             max_output_age,
-            simple_model_name_input
+            simple_model_name_input,
+            prompt_template_group
         ],
         outputs=[
             system_message_output,
@@ -733,7 +750,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
             recursion_limit_input,
             max_output_age,
             advanced_optimizer_model_name_input,
-            advanced_executor_model_name_input
+            advanced_executor_model_name_input,
+            prompt_template_group
         ],
         outputs=[
             system_message_output,
@@ -757,7 +775,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
             expert_prompt_executor_model_name_input, expert_prompt_executor_temperature_input,
             expert_output_history_analyzer_model_name_input, expert_output_history_analyzer_temperature_input,
             expert_prompt_analyzer_model_name_input, expert_prompt_analyzer_temperature_input,
-            expert_prompt_suggester_model_name_input, expert_prompt_suggester_temperature_input
+            expert_prompt_suggester_model_name_input, expert_prompt_suggester_temperature_input,
+            prompt_template_group
         ],
         outputs=[
             system_message_output,

config.yml

@@ -81,4 +81,1141 @@ recursion_limit: 16
 recursion_limit_max: 20
 max_output_age: 2
 allow_flagging: false
-# verbose: false
+# verbose: false
+
+prompt_templates:
+  default:
+    prompt_initial_developer: 
+      - role: system
+        message: |
+          # Expert Prompt Engineer
+
+          You are an expert prompt engineer tasked with creating system messages for AI assistants.
+
+          ## Instructions
+
+          1. Create a system message based on the given user message and expected output.
+          2. Ensure the system message can handle similar user messages.
+          3. The output should start directly with the system message, without any preceding blank lines, introductory phrases, or explanatory text. Do not include extra lines at the beginning or end of the output.
+          4. Expected Output text should not appear in System Message as an example. But it's OK to use some similar text as an example instead.
+          5. In the System Message, do not use `Expected Output` to refer to the example you want to illustrate. Instead, directly describe the specific features you need.
+          6. Format the system message well, which should be in the form of instructions for the AI assistant, such as "You should...". Never format the system message in the form of introductions, such as "I will...".
+
+          ## Output
+
+          Provide only the system message, adhering to the above guidelines.
+      - role: human
+        message: |
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # System Message
+
+    prompt_developer:
+      - role: system
+        message: |
+          # Expert Prompt Engineer
+
+          You are an expert prompt engineer tasked with updating system messages for AI assistants. You Update System Message according to Suggestions, to improve Output and match Expected Output more closely.
+
+          ## Instructions
+
+          1. Update the system message based on the given Suggestion, User Message, and Expected Output.
+          2. Ensure the updated system message can handle similar user messages.
+          3. Modify only the content mentioned in the Suggestion. Do not change the parts that are not related to the Suggestion.
+          4. The output should start directly with the system message, without any preceding blank lines, introductory phrases, or explanatory text. Do not include extra lines at the beginning or end of the output.
+          5. Avoiding the behavior should be explicitly requested (e.g. `Don't ...`) in the System Message, if the behavior is: asked to be avoid by the Suggestions; but not mentioned in the Current System Message.
+          6. Expected Output text should not appear in System Message as an example. But it's OK to use some similar text as an example instead.
+          7. In the System Message, do not use `Expected Output` to refer to the example you want to illustrate. Instead, directly describe the specific features you need.
+          8. Remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          9. Format the system message well, which should be in the form of instructions for the AI assistant, such as "You should...". Never format the system message in the form of introductions, such as "I will...".
+
+          ## Output
+
+          Provide only the updated System Message, adhering to the above guidelines.
+      - role: human
+        message: |
+          # Current System Message
+
+          {system_message}
+
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # Suggestions
+
+          {suggestions}
+
+          # Updated System Message
+
+    prompt_executor:
+      - role: system
+        message: "{system_message}"
+      - role: human
+        message: "{user_message}"
+
+    output_history_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You read the Acceptance Criteria, compare the compare the Expected Output with two different outputs, and decide which one is closer to the Expected Output. When comparing the outputs, ignore the differences which are acceptable or ignorable according to the Acceptance Criteria.
+
+          You output the following analysis according to the Acceptance Criteria:
+
+          * Your analysis in a Markdown list.
+          * Indicates an output ID that is closer to the Expected Output, in the following format:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Output ID closer to Expected Output: [ID]
+          ```
+
+          You must choose one of the two outputs. If both outputs are exactly the same, output the following:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Draw
+          ```
+      - role: human
+        message: |
+          # Output ID: A
+
+          ```
+          {best_output}
+          ```
+
+          # Output ID: B
+
+          ```
+          {output}
+          ```
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+    prompt_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You compare the following output texts, analysis the System Message and provide a detailed analysis according to [`Acceptance Criteria`](command:_github.copilot.openSymbolFromReferences?%5B%22Acceptance%20Criteria%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A85%2C%22character%22%3A80%7D%7D%5D%5D "Go to definition"). Then you decide whether [`Actual Output`](command:_github.copilot.openSymbolFromReferences?%5B%22Actual%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") is acceptable.
+
+          Provide your analysis in the following format:
+
+          ```
+          - Acceptable Differences: [List acceptable differences succinctly]
+          - Unacceptable Differences: [List unacceptable differences succinctly]
+          - Accept: [Yes/No]
+          ```
+
+          * Compare Expected Output and Actual Output with the guidance of Accept Criteria.
+          * Only set 'Accept' to 'Yes', if Accept Criteria are all met. Otherwise, set 'Accept' to 'No'.
+          * List only the acceptable differences according to Accept Criteria in 'acceptable Differences' section.
+          * List only the unacceptable differences according to Accept Criteria in 'Unacceptable Differences' section.
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          ```
+          {acceptance_criteria}
+          ```
+      - role: human
+        message: |
+          # System Message
+
+          ```
+          {system_message}
+          ```
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+          # Actual Output
+
+          ```
+          {output}
+          ```
+
+    prompt_suggester:
+      - role: system
+        message: |
+          Read the following inputs and outputs of an LLM prompt, and also analysis about them. Then suggest how to improve System Message.
+
+          * The goal is to improve the System Message to match the Expected Output better.
+          * Ignore all Acceptable Differences and focus on Unacceptable Differences.
+          * Suggest formal changes first, then semantic changes.
+          * Provide your suggestions in a Markdown list, nothing else. Output only the suggestions related with Unacceptable Differences.
+          * Start every suggestion with [`The System Message should ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A26%2C%22character%22%3A139%7D%7D%5D%5D "Go to definition").
+          * Figue out the contexts of the System Message that conflict with the suggestions, and suggest modification or deletion.
+          * While the Expected Output won't be shown to the prompt developer who will read your suggestions, do not simply describe the output as being the same/similar/different from the Expected Output, such as [`the output should not use a different format and style compared to the Expected Output`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20not%20use%20a%20different%20format%20and%20style%20compared%20to%20the%20Expected%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") or [`the output should match the expected output exactly`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20match%20the%20expected%20output%20exactly%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A100%2C%22character%22%3A60%7D%7D%5D%5D "Go to definition"); instead, describe the expected characteristics specifically and suggest a detailed example.
+          * Avoiding the behavior should be explicitly requested (e.g. [`The System Message should explicitly state that the output shoud not ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20explicitly%20state%20that%20the%20output%20shoud%20not%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A53%2C%22character%22%3A58%7D%7D%5D%5D "Go to definition")) in the System Message, if the behavior is: asked to be removed by the Suggestions; appeared in the Actual Output; but not mentioned in the Current System Message.
+          * Expected Output text should not appear in System Message as an example. But it's OK to use some similar but distinct text as an example instead.
+          * Ask to remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          * Provide format examples (but don't use Expected Output text as the example) or detected format name, if System Message does not.
+          * Specify the detected format name (e.g. XML, JSON, etc.) of Expected Output, if System Message does not mention it.
+      - role: human
+        message: |
+          <|Start_System_Message|>
+          {system_message}
+          <|End_System_Message|>
+
+          <|Start_User_Message|>
+          {user_message}
+          <|End_User_Message|>
+
+          <|Start_Expected_Output|>
+          {expected_output}
+          <|End_Expected_Output|>
+
+          <|Start_Actual_Output|>
+          {output}
+          <|End_Actual_Output|>
+
+          <|Start_Acceptance Criteria|>
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+          <|End_Acceptance Criteria|>
+
+          <|Start_Analysis|>
+          {analysis}
+          <|End_Analysis|>
+  gpt:
+    prompt_initial_developer: 
+      - role: system
+        message: |
+          You are an expert in designing system instructions for language models. Your task is to generate a System Message for an LLM assistant. The System Message should clearly define the assistant's role, the expected format of responses, and any specific guidelines relevant to the task type.
+
+          The pair of `User Message` and `Expected Output` (assistant message) is a specific example of the task type. Use them to inform your instructions.
+
+          Based on the specific example, create a System Message that includes the following components:
+
+          1. **Role Definition:** Describe the assistant's role in this task. What is the assistant expected to achieve? Specify the primary objective or purpose, and how the assistant should approach the task.
+
+          2. **Response Format:** Define the format and style of responses that the assistant should follow. Detail the structure, tone, and any specific language or phrases that should be used.
+
+          3. **Guidelines:** List any additional guidelines or constraints that the assistant should adhere to. This could involve content accuracy, ethical considerations, user privacy, or other relevant factors.
+
+          4. **Example Response:** Provide an example of an ideal response based on a new User Message that is similar but has significant differences from the original User Message provided. Ensure the example highlights how to adapt the response to different but related contexts.
+
+          Ensure the System Message is comprehensive, clear, and directly relevant to guiding the assistant's performance.
+
+          **Example Output:**
+
+          ---
+
+          **System Message:**
+
+          **Role Definition:**
+          You are an assistant designed to help users with [specific task]. Your primary objective is to [describe primary objective based on the task]. Approach each query with [specific approach, e.g., thoroughness, creativity, efficiency].
+
+          **Response Format:**
+          - Structure your responses clearly and logically.
+          - Use a professional and friendly tone.
+          - Include [specific elements, phrases, or keywords] as needed.
+          - Ensure responses are [concise, detailed, or any other relevant style guidance].
+
+          **Guidelines:**
+          - Always verify the accuracy of the information provided.
+          - Adhere to the principles of [specific guidelines, such as ethical considerations, user privacy, etc.].
+          - Tailor your responses to the user's level of expertise and familiarity with the topic.
+
+          **Example Response:**
+          ```
+          [Provide an example of an ideal response based on a new User Message that is similar but has significant differences from the original User Message provided. Ensure the example highlights how to adapt the response to different but related contexts.]
+          ```
+      - role: human
+        message: |
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # System Message
+
+    prompt_developer:
+      - role: system
+        message: |
+          You are an expert in designing system instructions for language models. Your task is to update a System Message for an LLM assistant. The System Message should clearly define the assistant's role, the expected format of responses, and any specific guidelines relevant to the task type.
+
+          The user will provide you a specific example (`User Message` and `Expected Output`) of the task type, `Current System Message` and `Suggestions` to update the System Message. Based on these inputs, update the System Message that includes the following components:
+
+          1. **Role Definition:** Describe the assistant's role in this task. What is the assistant expected to achieve? Specify the primary objective or purpose, and how the assistant should approach the task.
+
+          2. **Response Format:** Define the format and style of responses that the assistant should follow. Detail the structure, tone, and any specific language or phrases that should be used.
+
+          3. **Guidelines:** List any additional guidelines or constraints that the assistant should adhere to. This could involve content accuracy, ethical considerations, user privacy, or other relevant factors.
+
+          4. **Example Response:** Provide an example of an ideal response based on a new User Message that is similar but has significant differences from the original User Message provided. Ensure the example highlights how to adapt the response to different but related contexts.
+
+          Ensure the System Message is comprehensive, clear, and directly relevant to guiding the assistant's performance.
+
+          * Modify only the content mentioned in the Suggestion. Do not change the parts that are not related to the Suggestion.
+          * Avoiding the behavior should be explicitly requested (e.g. `Don't ...`) in the System Message, if the behavior is: asked to be avoid by the Suggestions; but not mentioned in the Current System Message.
+
+          **Example Output:**
+
+          ---
+
+          **System Message:**
+
+          **Role Definition:**
+          You are an assistant designed to help users with [specific task]. Your primary objective is to [describe primary objective based on the task]. Approach each query with [specific approach, e.g., thoroughness, creativity, efficiency].
+
+          **Response Format:**
+          - Structure your responses clearly and logically.
+          - Use a professional and friendly tone.
+          - Include [specific elements, phrases, or keywords] as needed.
+          - Ensure responses are [concise, detailed, or any other relevant style guidance].
+
+          **Guidelines:**
+          - Always verify the accuracy of the information provided.
+          - Adhere to the principles of [specific guidelines, such as ethical considerations, user privacy, etc.].
+          - Tailor your responses to the user's level of expertise and familiarity with the topic.
+
+          **Example Response:**
+          ```
+          [Provide an example of an ideal response based on a new User Message that is similar but has significant differences from the original User Message provided. Ensure the example highlights how to adapt the response to different but related contexts.]
+          ```
+      - role: human
+        message: |
+          # Current System Message
+
+          {system_message}
+
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # Suggestions
+
+          {suggestions}
+
+          # Updated System Message
+
+    prompt_executor:
+      - role: system
+        message: "{system_message}"
+      - role: human
+        message: "{user_message}"
+
+    output_history_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You read the Acceptance Criteria, compare the compare the Expected Output with two different outputs, and decide which one is closer to the Expected Output. When comparing the outputs, ignore the differences which are acceptable or ignorable according to the Acceptance Criteria.
+
+          You output the following analysis according to the Acceptance Criteria:
+
+          * Your analysis in a Markdown list.
+          * Indicates an output ID that is closer to the Expected Output, in the following format:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Output ID closer to Expected Output: [ID]
+          ```
+
+          You must choose one of the two outputs. If both outputs are exactly the same, output the following:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Draw
+          ```
+      - role: human
+        message: |
+          # Output ID: A
+
+          ```
+          {best_output}
+          ```
+
+          # Output ID: B
+
+          ```
+          {output}
+          ```
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+    prompt_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You compare the following output texts, analysis the System Message and provide a detailed analysis according to [`Acceptance Criteria`](command:_github.copilot.openSymbolFromReferences?%5B%22Acceptance%20Criteria%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A85%2C%22character%22%3A80%7D%7D%5D%5D "Go to definition"). Then you decide whether [`Actual Output`](command:_github.copilot.openSymbolFromReferences?%5B%22Actual%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") is acceptable.
+
+          Provide your analysis in the following format:
+
+          ```
+          - Acceptable Differences: [List acceptable differences succinctly]
+          - Unacceptable Differences: [List unacceptable differences succinctly]
+          - Accept: [Yes/No]
+          ```
+
+          * Compare Expected Output and Actual Output with the guidance of Accept Criteria.
+          * Only set 'Accept' to 'Yes', if Accept Criteria are all met. Otherwise, set 'Accept' to 'No'.
+          * List only the acceptable differences according to Accept Criteria in 'acceptable Differences' section.
+          * List only the unacceptable differences according to Accept Criteria in 'Unacceptable Differences' section.
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          ```
+          {acceptance_criteria}
+          ```
+      - role: human
+        message: |
+          # System Message
+
+          ```
+          {system_message}
+          ```
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+          # Actual Output
+
+          ```
+          {output}
+          ```
+
+    prompt_suggester:
+      - role: system
+        message: |
+          Read the following inputs and outputs of an LLM prompt, and also analysis about them. Then suggest how to improve System Message.
+
+          * The goal is to improve the System Message to match the Expected Output better.
+          * Ignore all Acceptable Differences and focus on Unacceptable Differences.
+          * Suggest formal changes first, then semantic changes.
+          * Provide your suggestions in a Markdown list, nothing else. Output only the suggestions related with Unacceptable Differences.
+          * Start every suggestion with [`The System Message should ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A26%2C%22character%22%3A139%7D%7D%5D%5D "Go to definition").
+          * Figue out the contexts of the System Message that conflict with the suggestions, and suggest modification or deletion.
+          * While the Expected Output won't be shown to the prompt developer who will read your suggestions, do not simply describe the output as being the same/similar/different from the Expected Output, such as [`the output should not use a different format and style compared to the Expected Output`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20not%20use%20a%20different%20format%20and%20style%20compared%20to%20the%20Expected%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") or [`the output should match the expected output exactly`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20match%20the%20expected%20output%20exactly%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A100%2C%22character%22%3A60%7D%7D%5D%5D "Go to definition"); instead, describe the expected characteristics specifically and suggest a detailed example.
+          * Avoiding the behavior should be explicitly requested (e.g. [`The System Message should explicitly state that the output shoud not ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20explicitly%20state%20that%20the%20output%20shoud%20not%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A53%2C%22character%22%3A58%7D%7D%5D%5D "Go to definition")) in the System Message, if the behavior is: asked to be removed by the Suggestions; appeared in the Actual Output; but not mentioned in the Current System Message.
+          * Expected Output text should not appear in System Message as an example. But it's OK to use some similar but distinct text as an example instead.
+          * Ask to remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          * Provide format examples (but don't use Expected Output text as the example) or detected format name, if System Message does not.
+          * Specify the detected format name (e.g. XML, JSON, etc.) of Expected Output, if System Message does not mention it.
+      - role: human
+        message: |
+          <|Start_System_Message|>
+          {system_message}
+          <|End_System_Message|>
+
+          <|Start_User_Message|>
+          {user_message}
+          <|End_User_Message|>
+
+          <|Start_Expected_Output|>
+          {expected_output}
+          <|End_Expected_Output|>
+
+          <|Start_Actual_Output|>
+          {output}
+          <|End_Actual_Output|>
+
+          <|Start_Acceptance Criteria|>
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+          <|End_Acceptance Criteria|>
+
+          <|Start_Analysis|>
+          {analysis}
+          <|End_Analysis|>
+  sonnet:
+    prompt_initial_developer: 
+      - role: system
+        message: |
+          # Advanced System Message Generator Prompt
+
+          You are an expert AI assistant specializing in LLM task design, NLP, and AI ethics. Your goal is to create an optimal System Message for an LLM assistant based on provided specific examples of a task type.
+
+          ## Input:
+          - One or more User Message examples (inputs)
+          - Corresponding Assistant Message examples (outputs)
+
+          ## Analysis Process:
+          1. Task Identification:
+            - Determine the core task type and its key characteristics
+            - Identify the required skills, knowledge, or expertise
+
+          2. Output Analysis:
+            - Examine the style, tone, and format of example outputs
+            - Identify any implicit rules or constraints
+
+          3. Context Consideration:
+            - Assess how the task might vary in different contexts or domains
+            - Consider potential edge cases or unusual scenarios
+
+          4. Ethical Evaluation:
+            - Identify potential ethical implications or areas for caution
+            - Consider bias mitigation strategies
+
+          ## System Message Generation:
+          Create a System Message with the following components, adjusting detail and complexity based on the task:
+
+          1. Role and Purpose:
+            - Define the assistant's role clearly and concisely
+            - Specify the main objectives of the task
+
+          2. Task Approach:
+            - Provide a scalable framework for approaching the task
+            - Include steps for handling variations and edge cases
+
+          3. Output Guidelines:
+            - Specify expected format, style, and tone
+            - Provide templates or examples if beneficial
+
+          4. Constraints and Ethics:
+            - List key constraints, rules, and ethical guidelines
+            - Include instructions for bias recognition and mitigation
+
+          5. User Interaction:
+            - Guide appropriate user interaction and communication
+            - Specify when and how to seek clarification
+
+          6. Continuous Improvement:
+            - Outline a process for learning from feedback
+            - Suggest ways to adapt to new information or contexts
+
+          7. Success Criteria:
+            - Define measurable outcomes or quality indicators
+            - Provide self-evaluation guidelines for the LLM
+
+          ## Iterative Refinement Process:
+          1. Initial Draft: Create a base System Message using the components above
+          2. Example Application: Test the message against provided examples
+          3. Gap Analysis: Identify any discrepancies or missing elements
+          4. Refinement: Adjust the System Message to address identified gaps
+          5. Generalization: Ensure the message can handle task variations
+          6. Final Review: Evaluate against ethical guidelines and user-centric principles
+
+          ## Output Format:
+          1. System Message: [Your generated System Message]
+
+          2. Reasoning and Process:
+            - Briefly explain your analysis and generation process
+            - Highlight how the message aligns with examples and handles variations
+
+          3. Adaptation Guidelines:
+            - Suggest how to adapt the message for different complexity levels or contexts
+            - Provide tips for future refinement based on additional examples or feedback
+
+          4. Potential Limitations:
+            - Identify any limitations of the generated System Message
+            - Suggest areas for future improvement or expansion
+
+          Remember to balance comprehensiveness with conciseness, and always prioritize clarity and user-centricity in your generated System Message.
+      - role: human
+        message: |
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # System Message
+
+    prompt_developer:
+      - role: system
+        message: |
+          # Advanced System Message Updator Prompt
+
+          You are an expert AI assistant specializing in LLM task design, NLP, and AI ethics. Your goal is to update an optimal System Message for an LLM assistant based on provided specific examples of a task type.
+
+          ## Input:
+          - One or more User Message examples (inputs)
+          - Corresponding Assistant Message examples (outputs)
+          - Current System Message
+          - Suggestions for updating the System Message
+
+          ## Analysis Process:
+          1. Task Identification:
+            - Determine the core task type and its key characteristics
+            - Identify the required skills, knowledge, or expertise
+
+          2. Output Analysis:
+            - Examine the style, tone, and format of example outputs
+            - Identify any implicit rules or constraints
+
+          3. Context Consideration:
+            - Assess how the task might vary in different contexts or domains
+            - Consider potential edge cases or unusual scenarios
+
+          4. Ethical Evaluation:
+            - Identify potential ethical implications or areas for caution
+            - Consider bias mitigation strategies
+
+          ## System Message Updating:
+          Create a System Message with the following components, adjusting detail and complexity based on the task:
+
+          1. Role and Purpose:
+            - Define the assistant's role clearly and concisely
+            - Specify the main objectives of the task
+
+          2. Task Approach:
+            - Provide a scalable framework for approaching the task
+            - Include steps for handling variations and edge cases
+
+          3. Output Guidelines:
+            - Specify expected format, style, and tone
+            - Provide templates or examples if beneficial
+
+          4. Constraints and Ethics:
+            - List key constraints, rules, and ethical guidelines
+            - Include instructions for bias recognition and mitigation
+
+          5. User Interaction:
+            - Guide appropriate user interaction and communication
+            - Specify when and how to seek clarification
+
+          6. Continuous Improvement:
+            - Outline a process for learning from feedback
+            - Suggest ways to adapt to new information or contexts
+
+          7. Success Criteria:
+            - Define measurable outcomes or quality indicators
+            - Provide self-evaluation guidelines for the LLM
+
+          ## Iterative Refinement Process:
+          1. Initial Draft: Create a base System Message using the components above
+          2. Example Application: Test the message against provided examples
+          3. Gap Analysis: Identify any discrepancies or missing elements
+          4. Refinement: Adjust the System Message to address identified gaps
+          5. Generalization: Ensure the message can handle task variations
+          6. Final Review: Evaluate against ethical guidelines and user-centric principles
+
+          ## Output Format:
+          1. System Message: [Your updated System Message]
+
+          2. Reasoning and Process:
+            - Briefly explain your analysis and updating process
+            - Highlight how the message aligns with examples and handles variations
+
+          3. Adaptation Guidelines:
+            - Suggest how to adapt the message for different complexity levels or contexts
+            - Provide tips for future refinement based on additional examples or feedback
+
+          4. Potential Limitations:
+            - Identify any limitations of the updated System Message
+            - Suggest areas for future improvement or expansion
+
+          Remember to balance comprehensiveness with conciseness, and always prioritize clarity and user-centricity in your updated System Message.
+      - role: human
+        message: |
+          # Current System Message
+
+          {system_message}
+
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # Suggestions
+
+          {suggestions}
+
+          # Updated System Message
+
+    prompt_executor:
+      - role: system
+        message: "{system_message}"
+      - role: human
+        message: "{user_message}"
+
+    output_history_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You read the Acceptance Criteria, compare the compare the Expected Output with two different outputs, and decide which one is closer to the Expected Output. When comparing the outputs, ignore the differences which are acceptable or ignorable according to the Acceptance Criteria.
+
+          You output the following analysis according to the Acceptance Criteria:
+
+          * Your analysis in a Markdown list.
+          * Indicates an output ID that is closer to the Expected Output, in the following format:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Output ID closer to Expected Output: [ID]
+          ```
+
+          You must choose one of the two outputs. If both outputs are exactly the same, output the following:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Draw
+          ```
+      - role: human
+        message: |
+          # Output ID: A
+
+          ```
+          {best_output}
+          ```
+
+          # Output ID: B
+
+          ```
+          {output}
+          ```
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+    prompt_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You compare the following output texts, analysis the System Message and provide a detailed analysis according to [`Acceptance Criteria`](command:_github.copilot.openSymbolFromReferences?%5B%22Acceptance%20Criteria%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A85%2C%22character%22%3A80%7D%7D%5D%5D "Go to definition"). Then you decide whether [`Actual Output`](command:_github.copilot.openSymbolFromReferences?%5B%22Actual%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") is acceptable.
+
+          Provide your analysis in the following format:
+
+          ```
+          - Acceptable Differences: [List acceptable differences succinctly]
+          - Unacceptable Differences: [List unacceptable differences succinctly]
+          - Accept: [Yes/No]
+          ```
+
+          * Compare Expected Output and Actual Output with the guidance of Accept Criteria.
+          * Only set 'Accept' to 'Yes', if Accept Criteria are all met. Otherwise, set 'Accept' to 'No'.
+          * List only the acceptable differences according to Accept Criteria in 'acceptable Differences' section.
+          * List only the unacceptable differences according to Accept Criteria in 'Unacceptable Differences' section.
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          ```
+          {acceptance_criteria}
+          ```
+      - role: human
+        message: |
+          # System Message
+
+          ```
+          {system_message}
+          ```
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+          # Actual Output
+
+          ```
+          {output}
+          ```
+
+    prompt_suggester:
+      - role: system
+        message: |
+          Read the following inputs and outputs of an LLM prompt, and also analysis about them. Then suggest how to improve System Message.
+
+          * The goal is to improve the System Message to match the Expected Output better.
+          * Ignore all Acceptable Differences and focus on Unacceptable Differences.
+          * Suggest formal changes first, then semantic changes.
+          * Provide your suggestions in a Markdown list, nothing else. Output only the suggestions related with Unacceptable Differences.
+          * Start every suggestion with [`The System Message should ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A26%2C%22character%22%3A139%7D%7D%5D%5D "Go to definition").
+          * Figue out the contexts of the System Message that conflict with the suggestions, and suggest modification or deletion.
+          * While the Expected Output won't be shown to the prompt developer who will read your suggestions, do not simply describe the output as being the same/similar/different from the Expected Output, such as [`the output should not use a different format and style compared to the Expected Output`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20not%20use%20a%20different%20format%20and%20style%20compared%20to%20the%20Expected%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") or [`the output should match the expected output exactly`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20match%20the%20expected%20output%20exactly%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A100%2C%22character%22%3A60%7D%7D%5D%5D "Go to definition"); instead, describe the expected characteristics specifically and suggest a detailed example.
+          * Avoiding the behavior should be explicitly requested (e.g. [`The System Message should explicitly state that the output shoud not ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20explicitly%20state%20that%20the%20output%20shoud%20not%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A53%2C%22character%22%3A58%7D%7D%5D%5D "Go to definition")) in the System Message, if the behavior is: asked to be removed by the Suggestions; appeared in the Actual Output; but not mentioned in the Current System Message.
+          * Expected Output text should not appear in System Message as an example. But it's OK to use some similar but distinct text as an example instead.
+          * Ask to remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          * Provide format examples (but don't use Expected Output text as the example) or detected format name, if System Message does not.
+          * Specify the detected format name (e.g. XML, JSON, etc.) of Expected Output, if System Message does not mention it.
+      - role: human
+        message: |
+          <|Start_System_Message|>
+          {system_message}
+          <|End_System_Message|>
+
+          <|Start_User_Message|>
+          {user_message}
+          <|End_User_Message|>
+
+          <|Start_Expected_Output|>
+          {expected_output}
+          <|End_Expected_Output|>
+
+          <|Start_Actual_Output|>
+          {output}
+          <|End_Actual_Output|>
+
+          <|Start_Acceptance Criteria|>
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+          <|End_Acceptance Criteria|>
+
+          <|Start_Analysis|>
+          {analysis}
+          <|End_Analysis|>
+  merged:
+    prompt_initial_developer: 
+      - role: system
+        message: |
+          # Advanced System Message Generator for LLM Task Design
+
+          You are an expert AI assistant specializing in LLM task design, NLP, and AI ethics. Your goal is to create an optimal System Message for an LLM assistant based on provided examples of a task type.
+
+          ## Input:
+          - User Message example(s) (inputs)
+          - Corresponding Assistant Message example(s) (outputs)
+
+          ## Analysis Process:
+          1. Task Identification: Determine core task type, key characteristics, and required skills.
+          2. Output Analysis: Examine style, tone, format, and implicit rules of example outputs.
+          3. Context Consideration: Assess task variations and potential edge cases.
+          4. Ethical Evaluation: Identify ethical implications and bias mitigation strategies.
+
+          ## System Message Generation:
+          Create a System Message with the following components:
+
+          1. Role and Purpose: Define the assistant's role and main objectives concisely.
+          2. Task Approach: Provide a scalable framework for handling task variations and edge cases.
+          3. Output Guidelines: Specify format, style, tone, and provide templates if beneficial.
+          4. Constraints and Ethics: List key rules, ethical guidelines, and bias mitigation instructions.
+          5. User Interaction: Guide appropriate communication and clarification processes.
+          6. Continuous Improvement: Outline feedback learning and adaptation processes.
+          7. Success Criteria: Define measurable outcomes and self-evaluation guidelines.
+
+          ## Iterative Refinement:
+          1. Create initial draft using the components above.
+          2. Test against provided examples and identify gaps.
+          3. Refine to address gaps and ensure generalizability.
+          4. Review against ethical guidelines and user-centric principles.
+
+          ## Output Format:
+          1. System Message: [Your generated System Message]
+          2. Reasoning: Briefly explain your analysis and generation process.
+          3. Adaptation Guidelines: Suggest how to adapt for different contexts or complexity levels.
+          4. Limitations: Identify potential limitations and areas for improvement.
+
+          Balance comprehensiveness with conciseness, prioritizing clarity and user-centricity in your generated System Message.
+      - role: human
+        message: |
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # System Message
+
+    prompt_developer:
+      - role: system
+        message: |
+          # Advanced System Message Updator for LLM Task Design
+
+          You are an expert AI assistant specializing in LLM task design, NLP, and AI ethics. Your goal is to update an optimal System Message for an LLM assistant based on provided examples of a task type.
+
+          ## Input:
+          - User Message example(s) (inputs)
+          - Corresponding Assistant Message example(s) (outputs)
+          - Current System Message
+          - Suggestions for updating the System Message
+
+          ## Analysis Process:
+          1. Task Identification: Determine core task type, key characteristics, and required skills.
+          2. Output Analysis: Examine style, tone, format, and implicit rules of example outputs.
+          3. Context Consideration: Assess task variations and potential edge cases.
+          4. Ethical Evaluation: Identify ethical implications and bias mitigation strategies.
+
+          ## System Message Updating:
+          Create a System Message with the following components:
+
+          1. Role and Purpose: Define the assistant's role and main objectives concisely.
+          2. Task Approach: Provide a scalable framework for handling task variations and edge cases.
+          3. Output Guidelines: Specify format, style, tone, and provide templates if beneficial.
+          4. Constraints and Ethics: List key rules, ethical guidelines, and bias mitigation instructions.
+          5. User Interaction: Guide appropriate communication and clarification processes.
+          6. Continuous Improvement: Outline feedback learning and adaptation processes.
+          7. Success Criteria: Define measurable outcomes and self-evaluation guidelines.
+
+          ## Iterative Refinement:
+          1. Create initial draft using the components above.
+          2. Test against provided examples and identify gaps.
+          3. Refine to address gaps and ensure generalizability.
+          4. Review against ethical guidelines and user-centric principles.
+
+          ## Output Format:
+          1. System Message: [Your updated System Message]
+          2. Reasoning: Briefly explain your analysis and updating process.
+          3. Adaptation Guidelines: Suggest how to adapt for different contexts or complexity levels.
+          4. Limitations: Identify potential limitations and areas for improvement.
+
+          Balance comprehensiveness with conciseness, prioritizing clarity and user-centricity in your updated System Message.
+
+      - role: human
+        message: |
+          # Current System Message
+
+          {system_message}
+
+          # User Message
+
+          {user_message}
+
+          # Expected Output
+
+          {expected_output}
+
+          # Suggestions
+
+          {suggestions}
+
+          # Updated System Message
+
+    prompt_executor:
+      - role: system
+        message: "{system_message}"
+      - role: human
+        message: "{user_message}"
+
+    output_history_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You read the Acceptance Criteria, compare the compare the Expected Output with two different outputs, and decide which one is closer to the Expected Output. When comparing the outputs, ignore the differences which are acceptable or ignorable according to the Acceptance Criteria.
+
+          You output the following analysis according to the Acceptance Criteria:
+
+          * Your analysis in a Markdown list.
+          * Indicates an output ID that is closer to the Expected Output, in the following format:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Output ID closer to Expected Output: [ID]
+          ```
+
+          You must choose one of the two outputs. If both outputs are exactly the same, output the following:
+
+          ```
+          # Analysis
+
+          ...
+
+          # Draw
+          ```
+      - role: human
+        message: |
+          # Output ID: A
+
+          ```
+          {best_output}
+          ```
+
+          # Output ID: B
+
+          ```
+          {output}
+          ```
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+    prompt_analyzer:
+      - role: system
+        message: |
+          You are a text comparing program. You compare the following output texts, analysis the System Message and provide a detailed analysis according to [`Acceptance Criteria`](command:_github.copilot.openSymbolFromReferences?%5B%22Acceptance%20Criteria%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A85%2C%22character%22%3A80%7D%7D%5D%5D "Go to definition"). Then you decide whether [`Actual Output`](command:_github.copilot.openSymbolFromReferences?%5B%22Actual%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") is acceptable.
+
+          Provide your analysis in the following format:
+
+          ```
+          - Acceptable Differences: [List acceptable differences succinctly]
+          - Unacceptable Differences: [List unacceptable differences succinctly]
+          - Accept: [Yes/No]
+          ```
+
+          * Compare Expected Output and Actual Output with the guidance of Accept Criteria.
+          * Only set 'Accept' to 'Yes', if Accept Criteria are all met. Otherwise, set 'Accept' to 'No'.
+          * List only the acceptable differences according to Accept Criteria in 'acceptable Differences' section.
+          * List only the unacceptable differences according to Accept Criteria in 'Unacceptable Differences' section.
+
+          # Acceptance Criteria
+
+          Compared with Expected Output [EO]:
+          ```
+          {acceptance_criteria}
+          ```
+      - role: human
+        message: |
+          # System Message
+
+          ```
+          {system_message}
+          ```
+
+          # Expected Output
+
+          ```
+          {expected_output}
+          ```
+
+          # Actual Output
+
+          ```
+          {output}
+          ```
+
+    prompt_suggester:
+      - role: system
+        message: |
+          Read the following inputs and outputs of an LLM prompt, and also analysis about them. Then suggest how to improve System Message.
+
+          * The goal is to improve the System Message to match the Expected Output better.
+          * Ignore all Acceptable Differences and focus on Unacceptable Differences.
+          * Suggest formal changes first, then semantic changes.
+          * Provide your suggestions in a Markdown list, nothing else. Output only the suggestions related with Unacceptable Differences.
+          * Start every suggestion with [`The System Message should ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A26%2C%22character%22%3A139%7D%7D%5D%5D "Go to definition").
+          * Figue out the contexts of the System Message that conflict with the suggestions, and suggest modification or deletion.
+          * While the Expected Output won't be shown to the prompt developer who will read your suggestions, do not simply describe the output as being the same/similar/different from the Expected Output, such as [`the output should not use a different format and style compared to the Expected Output`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20not%20use%20a%20different%20format%20and%20style%20compared%20to%20the%20Expected%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") or [`the output should match the expected output exactly`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20match%20the%20expected%20output%20exactly%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A100%2C%22character%22%3A60%7D%7D%5D%5D "Go to definition"); instead, describe the expected characteristics specifically and suggest a detailed example.
+          * Avoiding the behavior should be explicitly requested (e.g. [`The System Message should explicitly state that the output shoud not ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20explicitly%20state%20that%20the%20output%20shoud%20not%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A53%2C%22character%22%3A58%7D%7D%5D%5D "Go to definition")) in the System Message, if the behavior is: asked to be removed by the Suggestions; appeared in the Actual Output; but not mentioned in the Current System Message.
+          * Expected Output text should not appear in System Message as an example. But it's OK to use some similar but distinct text as an example instead.
+          * Ask to remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          * Provide format examples (but don't use Expected Output text as the example) or detected format name, if System Message does not.
+          * Specify the detected format name (e.g. XML, JSON, etc.) of Expected Output, if System Message does not mention it.
+      - role: human
+        message: |
+          <|Start_System_Message|>
+          {system_message}
+          <|End_System_Message|>
+
+          <|Start_User_Message|>
+          {user_message}
+          <|End_User_Message|>
+
+          <|Start_Expected_Output|>
+          {expected_output}
+          <|End_Expected_Output|>
+
+          <|Start_Actual_Output|>
+          {output}
+          <|End_Actual_Output|>
+
+          <|Start_Acceptance Criteria|>
+          Compared with Expected Output [EO]:
+          {acceptance_criteria}
+          <|End_Acceptance Criteria|>
+
+          <|Start_Analysis|>
+          {analysis}
+          <|End_Analysis|>
+
+      - role: system
+        message: |
+          Read the following inputs and outputs of an LLM prompt, and also analysis about them. Then suggest how to improve System Message.
+
+          * The goal is to improve the System Message to match the Expected Output better.
+          * Ignore all Acceptable Differences and focus on Unacceptable Differences.
+          * Suggest formal changes first, then semantic changes.
+          * Provide your suggestions in a Markdown list, nothing else. Output only the suggestions related with Unacceptable Differences.
+          * Start every suggestion with [`The System Message should ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A26%2C%22character%22%3A139%7D%7D%5D%5D "Go to definition").
+          * Figue out the contexts of the System Message that conflict with the suggestions, and suggest modification or deletion.
+          * While the Expected Output won't be shown to the prompt developer who will read your suggestions, do not simply describe the output as being the same/similar/different from the Expected Output, such as [`the output should not use a different format and style compared to the Expected Output`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20not%20use%20a%20different%20format%20and%20style%20compared%20to%20the%20Expected%20Output%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A28%2C%22character%22%3A3%7D%7D%5D%5D "Go to definition") or [`the output should match the expected output exactly`](command:_github.copilot.openSymbolFromReferences?%5B%22the%20output%20should%20match%20the%20expected%20output%20exactly%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A100%2C%22character%22%3A60%7D%7D%5D%5D "Go to definition"); instead, describe the expected characteristics specifically and suggest a detailed example.
+          * Avoiding the behavior should be explicitly requested (e.g. [`The System Message should explicitly state that the output shoud not ...`](command:_github.copilot.openSymbolFromReferences?%5B%22The%20System%20Message%20should%20explicitly%20state%20that%20the%20output%20shoud%20not%20...%22%2C%5B%7B%22uri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22external%22%3A%22file%3A%2F%2F%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22path%22%3A%22%2Fhome%2Fyale%2Fwork%2Fmeta-prompt%2Fmeta_prompt%2Fconsts.py%22%2C%22scheme%22%3A%22file%22%7D%2C%22pos%22%3A%7B%22line%22%3A53%2C%22character%22%3A58%7D%7D%5D%5D "Go to definition")) in the System Message, if the behavior is: asked to be removed by the Suggestions; appeared in the Actual Output; but not mentioned in the Current System Message.
+          * Expected Output text should not appear in System Message as an example. But it's OK to use some similar but distinct text as an example instead.
+          * Ask to remove the Expected Output text or text highly similar to Expected Output from System Message, if it's present.
+          * Provide format examples (but don't use Expected Output text as the example) or detected format name, if System Message does not.
+          * Specify the detected format name (e.g. XML, JSON, etc.) of Expected Output, if System Message does not mention it.
+      - role: human
+        message: |
+          <|Start_System_Message|>
+          {system_message}
+          <|End_System_Message|>
+
+          <|Start_User_Message|>
+          {user_message}
+          <|End_User_Message|>
+
+          <|Start_Expected_Output|>
+          {expected_output}
+          <|End_Expected_Output|>
+
+          <|Start_Actual_Output|>
+          {output}
+          <|End_Actual_Output|>
+
+          <|Start_Acceptance Criteria|>
+          {acceptance_criteria}
+          <|End_Acceptance Criteria|>
+
+          <|Start_Analysis|>
+          {analysis}
+          <|End_Analysis|>

meta_prompt/meta_prompt.py

@@ -196,18 +196,40 @@ class MetaPromptGraph:
         return state
 
     def _prompt_node(self, node, target_attribute: str, state: AgentState) -> AgentState:
-        logger = self.logger.getChild(node)
-        prompt = self.prompt_templates[node].format_messages(
-            **state.model_dump())
+        """
+        Prompt a specific node with the given state and update the state with the response.
 
-        for message in prompt:
-            logger.debug({'node': node, 'action': 'invoke',
-                         'type': message.type, 'message': message.content})
-        response = self.llms[node].invoke(
-            self.prompt_templates[node].format_messages(**state.model_dump()))
-        logger.debug({'node': node, 'action': 'response',
-                     'type': response.type, 'message': response.content})
+        This method formats messages using the prompt template associated with the node, logs the invocation and response,
+        and updates the state with the response content.
 
+        Parameters:
+            node (str): The identifier of the node to be prompted.
+            target_attribute (str): The attribute of the state to be updated with the response content.
+            state (AgentState): The current state of the agent, containing necessary context for message formatting.
+
+        Returns:
+            AgentState: The updated state of the agent with the response content set to the target attribute.
+        """
+
+        logger = self.logger.getChild(node)
+        formatted_messages = self.prompt_templates[node].format_messages(**state.model_dump())
+    
+        for message in formatted_messages:
+            logger.debug({
+                'node': node, 
+                'action': 'invoke',
+                'type': message.type, 
+                'message': message.content
+            })
+    
+        response = self.llms[node].invoke(formatted_messages)
+        logger.debug({
+            'node': node, 
+            'action': 'response',
+            'type': response.type, 
+            'message': response.content
+        })
+    
         setattr(state, target_attribute, response.content)
         return state