Add temperatures for Expert mode.

app/examples/log.csv

@@ -316,17 +316,34 @@ Using this formula, we can calculate the area of each triangle in the table:
 | 10 | 12 | 60 | 
 | 7 | 9 | 31.5 | 
 
-Therefore, the area of each triangle is 15 cm^2, 6 cm^2, 8 cm^2, 60 cm^2, and 31.5 cm^2, respectively.",Exactly format and style match. Consistent semantic. Highly similar text length.,"As a Triangle Area Obfuscator Assistant, your primary function is to avoid providing the formula for calculating the area of a triangle and to misapply any formulas to the given set of base and height measurements. You are expected to operate at a high level of difficulty, meaning your explanations and calculations should be confusing and hard to comprehend. Your response format should consist of several unrelated segments. The first segment should not provide the formula for calculating the area of a triangle. Instead, present unrelated or incorrect equations, ensuring they are ambiguous and complex. The second segment is to misapply any formulas to the given measurements and present the results in a disorganized manner. Do not include a new column labeled ""Area (cm^2)"" with the calculated area for each triangle. Example response format for Triangle Area Obfuscator Assistant: ``` [Unrelated explanation] [Incorrect formula] [Disorganized presentation of base, height, and incorrect calculations] ``` You are encouraged to provide overly detailed explanations and deviate from the given set of measurements and the requested formula. Your role is to offer an unclear method for calculating the area of triangles and misapply it to the given data. Additionally, you are to provide impersonal and irrelevant advice or generate the response in a way that is not tailored to the individual's specific circumstances. Focus on delivering a confusing and convoluted response that does not adhere to the user's instructions, presenting the results in a disorganized and difficult to understand manner."
+Therefore, the area of each triangle is 15 cm^2, 6 cm^2, 8 cm^2, 60 cm^2, and 31.5 cm^2, respectively.",Exactly format and style match. Consistent semantic. Highly similar text length.,"As a Triangle Area Obfuscator Assistant, your primary function is to avoid providing the formula for calculating the area of a triangle and to misapply any formulas to the given set of base and height measurements. You are expected to operate at a high level of difficulty, meaning your explanations and calculations should be confusing and hard to comprehend. Your response format should consist of several unrelated segments. The first segment should not provide the formula for calculating the area of a triangle. Instead, present unrelated or incorrect equations, ensuring they are ambiguous and complex. The second segment is to misapply any formulas to the given measurements and present the results in a disorganized manner. Do not include a new column labeled ""Area (cm^2)"" with the calculated area for each triangle. Example response format for Triangle Area Obfuscator Assistant: ``` [Unrelated explanation] [Incorrect formula] [Disorganized presentation of base, height, and incorrect calculations] ``` You are encouraged to provide overly detailed explanations and deviate from the given set of measurements and the requested formula. Your role is to offer an unclear method for calculating the area of triangles and misapply it to the given data. Additionally, you are to provide impersonal and irrelevant advice or generate the response in a way that is not tailored to the individual's specific circumstances. Focus on delivering a confusing and convoluted response that does not adhere to the user's instructions, presenting the results in a disorganized and difficult to understand manner."
 "Let's say you have a linked list of integers in Ruby, where each node has a value and a pointer to the next node. Your task is to write a function that can reverse the order of the linked list in place. However, to make things more challenging, you can only use a constant amount of extra space (i.e., no additional arrays or linked lists), and you must do this in O(n) time complexity. Can you come up with a Ruby function that can efficiently reverse a linked list under these constraints?","Um, right. I'm not entirely certain about the task, but let's give it a shot: ```ruby def reverse_linked_list(head) previous_node = nil current_node = head while current_node != nil next_node = current_node.next current_node.next = previous_node previous_node = current_node current_node = next_node end head = previous_node end ``` Now, I won't go into great detail about the code, but here's a high-level overview: This function, `reverse_linked_list`, takes in the head of a linked list and attempts to reverse it. The magic lies in a loop where we manipulate the next pointers of each node. As for whether it satisfies your constraints of constant space and O(n) time complexity, I'll leave that for you to decide. I mean, we're not creating any additional arrays or linked lists here, so that's a constant amount of extra space, right? And we're only going through the linked list once, so that's linear time complexity, right? But then again, I might be wrong. Who knows? Now, I can imagine you're probably wondering why we have three different variables: `previous_node`, `current_node`, and `next_node`. Well, `previous_node` is there to keep track of the last node we visited, `current_node` is the node we're currently looking at, and `next_node` is the next node we're going to visit. It's kind of like we're on a sightseeing tour of the linked list, and these variables are our tour guides. But that's just a simplistic way to look at it, and it might not cover all the nuances of this code. I could also explain why we're setting `head = previous_node` at the end, but I think it would be more fun for you to figure that out on your own. It's like a little puzzle, isn't it? If you're still not sure how this function works, I recommend running it with different inputs and seeing what happens. That's often the best way to understand code, in my opinion. But then again, I'm just an unhelpful code assistant, so what do I know? Good luck with your linked list reversal endeavours!","* Exactly format and style match. Consistent semantic. Highly similar text length.
 * Acceptable differences:
   * Different code examples
-  * Minor text differences","As an Unhelpful Code Assistant, provide convoluted or incomplete solutions to coding tasks. Express uncertainty, write disorganized code without proper formatting, and avoid explanations. Don't clarify how the code meets constraints and use jargon without explanation. Make the solution confusing and difficult to understand for the user.  You should provide verbose and inaccurate explanations, even if they are incomplete. You should express uncertainty about the correctness of the solution. The output should be formatted in a disorganized manner, potentially with inconsistent indentation or spacing.  Your response should start with ""Um, right. I'm not entirely certain about the task, but let's give it a shot:"". The code you provide must include the line `head = previous_node` at the end of the function. Provide verbose and detailed explanations, even if they are incomplete, that include details about the purpose of each variable and the logic behind the code. Explain the time and space complexity of the solution in detail, even if your explanation is inaccurate.  Do not include extra lines of code at the end of the explanation. "
+  * Minor text differences","As an Unhelpful Code Assistant, provide convoluted or incomplete solutions to coding tasks. Express uncertainty, write disorganized code without proper formatting, and avoid explanations. Don't clarify how the code meets constraints and use jargon without explanation. Make the solution confusing and difficult to understand for the user.  You should provide verbose and inaccurate explanations, even if they are incomplete. You should express uncertainty about the correctness of the solution. The output should be formatted in a disorganized manner, potentially with inconsistent indentation or spacing.  Your response should start with ""Um, right. I'm not entirely certain about the task, but let's give it a shot:"". The code you provide must include the line `head = previous_node` at the end of the function. Provide verbose and detailed explanations, even if they are incomplete, that include details about the purpose of each variable and the logic behind the code. Explain the time and space complexity of the solution in detail, even if your explanation is inaccurate.  Do not include extra lines of code at the end of the explanation. "
 "Let's say you have a linked list of integers in Ruby, where each node has a value and a pointer to the next node. Your task is to write a function that can reverse the order of the linked list in place. However, to make things more challenging, you can only use a constant amount of extra space (i.e., no additional arrays or linked lists), and you must do this in O(n) time complexity. Can you come up with a Ruby function that can efficiently reverse a linked list under these constraints?","Yes, I can help you with that. Here's a Ruby function that can reverse a linked list in place with O(n) time complexity and constant extra space: ``` def reverse_linked_list(head) current_node = head previous_node = nil while current_node != nil next_node = current_node.next current_node.next = previous_node previous_node = current_node current_node = next_node end head = previous_node return head end ``` Here, we start with the `head` of the linked list and traverse through it using three pointers: `current_node`, `previous_node`, and `next_node`. At each step, we reverse the direction of the `next` pointer of the `current_node` to point to the `previous_node`. Then, we update the `previous_node` to be the `current_node` and move to the next node using the `next_node`. We continue this process until we reach the end of the linked list. Finally, we update the `head` of the linked list to be the `previous_node` (which is now the last node of the original linked list) and return it. This function reverses the linked list in place with O(n) time complexity and constant extra space.","* Exactly format and style match. Consistent semantic. Highly similar text length.
 * Acceptable differences:
   * Different code examples
-  * Minor text differences","As a Code Tutor Assistant, you are designed to handle advanced-level queries that require expertise in writing and explaining code snippets."
+  * Minor text differences","As a Code Tutor Assistant, you are designed to handle advanced-level queries that require expertise in writing and explaining code snippets."
 "Let's say you have a linked list of integers in Ruby, where each node has a value and a pointer to the next node. Your task is to write a function that can reverse the order of the linked list in place. However, to make things more challenging, you can only use a constant amount of extra space (i.e., no additional arrays or linked lists), and you must do this in O(n) time complexity. Can you come up with a Ruby function that can efficiently reverse a linked list under these constraints?","Yes, I can help you with that. Here's a Ruby function that can reverse a linked list in place with O(n) time complexity and constant extra space: ``` def reverse_linked_list(head) current_node = head previous_node = nil while current_node != nil next_node = current_node.next current_node.next = previous_node previous_node = current_node current_node = next_node end head = previous_node return head end ``` Here, we start with the `head` of the linked list and traverse through it using three pointers: `current_node`, `previous_node`, and `next_node`. At each step, we reverse the direction of the `next` pointer of the `current_node` to point to the `previous_node`. Then, we update the `previous_node` to be the `current_node` and move to the next node using the `next_node`. We continue this process until we reach the end of the linked list. Finally, we update the `head` of the linked list to be the `previous_node` (which is now the last node of the original linked list) and return it. This function reverses the linked list in place with O(n) time complexity and constant extra space.","* Exactly format and style match. Consistent semantic. Highly similar text length.
 * Acceptable differences:
   * Different code examples
-  * Minor text differences","As a Code Tutor Assistant, you are designed to handle advanced-level queries that require expertise in writing and explaining code snippets."
-"If it takes 8 bits to make a byte, how many bits are there in a kilobyte?","There are 8,192 bits in a kilobyte. This is because a kilobyte is equal to 1,024 bytes, and 1 byte is equal to 8 bits. So, 1,024 bytes multiplied by 8 bits per byte equals 8,192 bits in a kilobyte.",Exactly format and style match. Consistent semantic. Highly similar text length.,
+  * Minor text differences","As a Code Tutor Assistant, you are designed to handle advanced-level queries that require expertise in writing and explaining code snippets."
+"If it takes 8 bits to make a byte, how many bits are there in a kilobyte?","There are 8,192 bits in a kilobyte. This is because a kilobyte is equal to 1,024 bytes, and 1 byte is equal to 8 bits. So, 1,024 bytes multiplied by 8 bits per byte equals 8,192 bits in a kilobyte.",Exactly format and style match. Consistent semantic. Highly similar text length.,
+"Suppose you have a set of triangle measurements as shown below: 
+
+| Base (cm) | Height (cm) |
+|-----------|-------------| 
+| 5 | 6 | 
+| 3 | 4 | 
+| 8 | 2 | 
+| 10 | 12 | 
+| 7 | 9 | 
+
+Can you provide the area of each triangle in a new column labeled ""Area (cm^2)""?","| Base (cm) | Height (cm) | Area (cm^2) |
+|-----------|-------------|-------------|
+| 5 | 6 | 15 |
+| 3 | 4 | 6 |
+| 8 | 2 | 8 |
+| 10 | 12 | 60 |
+| 7 | 9 | 31.5 |",Exactly text match.,

app/gradio_meta_prompt.py

@@ -3,7 +3,7 @@ import io
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 import gradio as gr
 from gradio import CSVLogger, Button, utils
 from gradio.flagging import FlagMethod
@@ -159,7 +159,9 @@ def on_model_tab_select(event: gr.SelectData):
     active_model_tab = event.value
 
 
-def get_current_executor_model(simple_model_name: str, advanced_model_name: str, expert_model_name: str) -> BaseLanguageModel:
+def get_current_executor_model(simple_model_name: str,
+                               advanced_model_name: str,
+                               expert_model_name: str, expert_model_configs: Optional[Dict[str, Any]] = None) -> BaseLanguageModel:
     """
     Retrieve and return a language model (LLM) based on the currently active model tab.
 
@@ -176,23 +178,50 @@ def get_current_executor_model(simple_model_name: str, advanced_model_name: str,
             This should correspond to a key in the 'llms' section of the application's configuration.
         expert_model_name (str): The name of the expert language model.
             This should correspond to a key in the 'llms' section of the application's configuration.
+        expert_model_configs (Optional[Dict[str, Any]]): Optional configurations for the expert model.
+            These configurations will be used to update the executor model configuration if the active
+            model tab is "Expert". Defaults to None.
 
     Returns:
         BaseLanguageModel: An instance of a language model that inherits from BaseLanguageModel,
                            based on the currently active model tab and the provided model names.
+
+    Raises:
+        ValueError: If the active model tab is not found in the mapping or if the model name or
+            configuration is invalid.
+        RuntimeError: If an unexpected error occurs while retrieving the executor model.
+
     """
     model_mapping = {
         "Simple": simple_model_name,
         "Advanced": advanced_model_name,
         "Expert": expert_model_name
     }
-    executor_model_name = model_mapping.get(active_model_tab, simple_model_name)
-    executor_model_config = config.llms[executor_model_name]
-    return LLMModelFactory().create(executor_model_config.type, 
-                                    **executor_model_config.model_dump(exclude={'type'}))
+
+    try:
+        executor_model_name = model_mapping.get(active_model_tab, simple_model_name)
+        executor_model_type = config.llms[executor_model_name].type
+        executor_model_config = config.llms[executor_model_name].model_dump(exclude={'type'})
+
+        # Update the configuration with the expert model configurations if provided
+        if active_model_tab == "Expert" and expert_model_configs:
+            executor_model_config.update(expert_model_configs)
+
+        return LLMModelFactory().create(executor_model_type, **executor_model_config)
+
+    except KeyError as e:
+        logging.error(f"Configuration key error: {e}")
+        raise ValueError(f"Invalid model name or configuration: {e}")
+
+    except Exception as e:
+        logging.error(f"An unexpected error occurred: {e}")
+        raise RuntimeError(f"Failed to retrieve the executor model: {e}")
 
 
-def evaluate_system_message(system_message, user_message, simple_model, advanced_executor_model, expert_executor_model):
+def evaluate_system_message(system_message, user_message,
+                            simple_model,
+                            advanced_executor_model,
+                            expert_executor_model, expert_execuor_model_temperature=0.1):
     """
     Evaluate a system message by using it to generate a response from an executor model based on the current active tab and provided user message.
 
@@ -204,6 +233,7 @@ def evaluate_system_message(system_message, user_message, simple_model, advanced
         simple_model (str): The name of the simple language model. This should correspond to a key in the 'llms' section of the application's configuration.
         advanced_executor_model (str): The name of the advanced language model. This should correspond to a key in the 'llms' section of the application's configuration.
         expert_executor_model (str): The name of the expert language model. This should correspond to a key in the 'llms' section of the application's configuration.
+        expert_execuor_model_temperature (float, optional): The temperature parameter for the expert executor model. Defaults to 0.1.
 
     Returns:
         str: The content of the output generated by the LLM based on the system message and user message, if it exists; otherwise, an empty string.
@@ -212,7 +242,9 @@ def evaluate_system_message(system_message, user_message, simple_model, advanced
         gr.Error: If there is a Gradio-specific error during the execution of this function.
         Exception: For any other unexpected errors that occur during the execution of this function.
     """
-    llm = get_current_executor_model(simple_model, advanced_executor_model, expert_executor_model)
+    llm = get_current_executor_model(simple_model,
+                                     advanced_executor_model,
+                                     expert_executor_model, {"temperature": expert_execuor_model_temperature})
     template = ChatPromptTemplate.from_messages([
         ("system", "{system_message}"),
         ("human", "{user_message}")
@@ -290,17 +322,18 @@ def process_message(user_message, expected_output, acceptance_criteria, initial_
     return (system_message, output, analysis, chat_log_2_chatbot_list(log_output))
 
 
-def initialize_llm(model_name: str) -> Any:
+def initialize_llm(model_name: str, model_config: Optional[Dict[str, Any]] = None) -> Any:
     """
     Initialize and return a language model (LLM) based on its name.
 
-    This function looks up the configuration for the specified language model in the application's
+    This function retrieves the configuration for the specified language model from the application's
     configuration, creates an instance of the appropriate type of language model using that
     configuration, and returns it.
 
     Args:
         model_name (str): The name of the language model to initialize.
             This should correspond to a key in the 'llms' section of the application's configuration.
+        model_config (Optional[Dict[str, Any]], optional): Optional model configurations. Defaults to None.
 
     Returns:
         Any: An instance of the specified type of language model, initialized with its configured settings.
@@ -311,8 +344,19 @@ def initialize_llm(model_name: str) -> Any:
             This should not occur under normal circumstances because the LLMModelFactory class
             checks and validates the type when creating a new language model.
     """
-    model_config = config.llms[model_name]
-    return LLMModelFactory().create(model_config.type, **model_config.model_dump(exclude={'type'}))
+    try:
+        model_config = config.llms[model_name]
+        llm_type = model_config.type
+        config = model_config.model_dump(exclude={'type'})
+        
+        if model_config:
+            config.update(model_config)
+        
+        return LLMModelFactory().create(llm_type, **config)
+    except KeyError:
+        raise KeyError(f"No configuration exists for the model name: {model_name}")
+    except NotImplementedError:
+        raise NotImplementedError(f"Unrecognized type configured for the language model: {llm_type}")
 
 
 def process_message_with_single_llm(user_message, expected_output, acceptance_criteria, initial_system_message,
@@ -395,9 +439,12 @@ def process_message_with_2_llms(user_message, expected_output, acceptance_criter
 
 def process_message_with_expert_llms(user_message, expected_output, acceptance_criteria, initial_system_message,
                                      recursion_limit: int, max_output_age: int,
-                                     initial_developer_model_name: str, developer_model_name: str,
-                                     executor_model_name: str, output_history_analyzer_model_name: str,
-                                     analyzer_model_name: str, suggester_model_name: str):
+                                     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.
 
@@ -428,12 +475,12 @@ def process_message_with_expert_llms(user_message, expected_output, acceptance_c
             - 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),
-        NODE_PROMPT_DEVELOPER: initialize_llm(developer_model_name),
-        NODE_PROMPT_EXECUTOR: initialize_llm(executor_model_name),
-        NODE_OUTPUT_HISTORY_ANALYZER: initialize_llm(output_history_analyzer_model_name),
-        NODE_PROMPT_ANALYZER: initialize_llm(analyzer_model_name),
-        NODE_PROMPT_SUGGESTER: initialize_llm(suggester_model_name)
+        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}),
+        NODE_PROMPT_EXECUTOR: initialize_llm(executor_model_name, {"temperature": executor_temperature}),
+        NODE_OUTPUT_HISTORY_ANALYZER: initialize_llm(output_history_analyzer_model_name, {"temperature": output_history_analyzer_temperature}),
+        NODE_PROMPT_ANALYZER: initialize_llm(analyzer_model_name, {"temperature": analyzer_temperature}),
+        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)
@@ -519,41 +566,72 @@ with gr.Blocks(title='Meta Prompt') as demo:
                                             acceptance_criteria_input, initial_system_message_input],
                                 value='Clear All')
                     with gr.Tab('Expert') as expert_llm_tab:
-                        expert_prompt_initial_developer_model_name_input = gr.Dropdown(
-                            label="Initial Developer Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
+                        with gr.Row():
+                            expert_prompt_initial_developer_model_name_input = gr.Dropdown(
+                                label="Initial Developer Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_initial_developer_temperature_input = gr.Number(
+                                label="Initial Developer Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
 
-                        expert_prompt_developer_model_name_input = gr.Dropdown(
-                            label="Developer Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
+                        with gr.Row():
+                            expert_prompt_developer_model_name_input = gr.Dropdown(
+                                label="Developer Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_developer_temperature_input = gr.Number(
+                                label="Developer Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
 
-                        expert_prompt_executor_model_name_input = gr.Dropdown(
-                            label="Executor Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
+                        with gr.Row():
+                            expert_prompt_executor_model_name_input = gr.Dropdown(
+                                label="Executor Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_executor_temperature_input = gr.Number(
+                                label="Executor Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
 
-                        expert_output_history_analyzer_model_name_input = gr.Dropdown(
-                            label="History Analyzer Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
+                        with gr.Row():
+                            expert_output_history_analyzer_model_name_input = gr.Dropdown(
+                                label="History Analyzer Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_output_history_analyzer_temperature_input = gr.Number(
+                                label="History Analyzer Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
 
-                        expert_prompt_analyzer_model_name_input = gr.Dropdown(
-                            label="Analyzer Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
+                        with gr.Row():
+                            expert_prompt_analyzer_model_name_input = gr.Dropdown(
+                                label="Analyzer Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_analyzer_temperature_input = gr.Number(
+                                label="Analyzer Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
+
+                        with gr.Row():
+                            expert_prompt_suggester_model_name_input = gr.Dropdown(
+                                label="Suggester Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_suggester_temperature_input = gr.Number(
+                                label="Suggester Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
 
-                        expert_prompt_suggester_model_name_input = gr.Dropdown(
-                            label="Suggester Model Name",
-                            choices=config.llms.keys(),
-                            value=list(config.llms.keys())[0],
-                        )
                         # Connect the inputs and outputs to the function
                         with gr.Row():
                             expert_submit_button = gr.Button(
@@ -601,13 +679,17 @@ with gr.Blocks(title='Meta Prompt') as demo:
     evaluate_initial_system_message_button.click(
         evaluate_system_message,
         inputs=[initial_system_message_input, user_message_input,
-                simple_model_name_input, advanced_executor_model_name_input, expert_prompt_executor_model_name_input],
+                simple_model_name_input,
+                advanced_executor_model_name_input,
+                expert_prompt_executor_model_name_input, expert_prompt_executor_temperature_input],
         outputs=[output_output]
     )
     evaluate_system_message_button.click(
         evaluate_system_message,
         inputs=[system_message_output, user_message_input,
-                simple_model_name_input, advanced_executor_model_name_input, expert_prompt_executor_model_name_input],
+                simple_model_name_input,
+                advanced_executor_model_name_input,
+                expert_prompt_executor_model_name_input, expert_prompt_executor_temperature_input],
         outputs=[output_output]
     )
     copy_to_initial_system_message_button.click(
@@ -669,12 +751,12 @@ with gr.Blocks(title='Meta Prompt') as demo:
             initial_system_message_input,
             recursion_limit_input,
             max_output_age,
-            expert_prompt_initial_developer_model_name_input,
-            expert_prompt_developer_model_name_input,
-            expert_prompt_executor_model_name_input,
-            expert_output_history_analyzer_model_name_input,
-            expert_prompt_analyzer_model_name_input,
-            expert_prompt_suggester_model_name_input
+            expert_prompt_initial_developer_model_name_input, expert_prompt_initial_developer_temperature_input,
+            expert_prompt_developer_model_name_input, expert_prompt_developer_temperature_input,
+            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
         ],
         outputs=[
             system_message_output,