Added functions for generating acceptance criteria.

app/gradio_meta_prompt.py

@@ -498,6 +498,25 @@ def process_message_with_expert_llms(user_message: str, expected_output: str,
                            recursion_limit, max_output_age, llms, prompt_template_group=prompt_template_group)
 
 
+def generate_acceptance_criteria(user_message, expected_output, model_name):
+    """
+    Generate acceptance criteria based on the user message and expected output.
+    """
+    prompt = f"""Given the following user message and expected output, generate appropriate acceptance criteria:
+
+User Message: {user_message}
+Expected Output: {expected_output}
+
+Generate concise and specific acceptance criteria that can be used to evaluate the quality and relevance of the expected output in relation to the user message. The criteria should focus on key aspects such as relevance, accuracy, completeness, and clarity.
+
+Acceptance Criteria:
+"""
+    
+    llm = initialize_llm(model_name)
+    response = llm.invoke(prompt)
+    return response.content if hasattr(response, 'content') else ""
+
+
 class FileConfig(BaseConfig):
     config_file: str = 'config.yml'  # default path
 
@@ -527,25 +546,58 @@ with gr.Blocks(title='Meta Prompt') as demo:
     with gr.Row():
         with gr.Column():
             user_message_input = gr.Textbox(
-                label="User Message", show_copy_button=True)
+                label="User Message",
+                show_copy_button=True
+            )
             expected_output_input = gr.Textbox(
-                label="Expected Output", show_copy_button=True)
-            acceptance_criteria_input = gr.Textbox(
-                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(
-                value="Evaluate", variant="secondary")
+                label="Expected Output",
+                show_copy_button=True
+            )
+            with gr.Group():
+                with gr.Row():
+                    acceptance_criteria_input = gr.Textbox(
+                        label="Acceptance Criteria (Compared with Expected Output [EO])",
+                        show_copy_button=True,
+                        scale=4  # This makes it take up 3/4 of the row width
+                    )
+                    generate_acceptance_criteria_button = gr.Button(
+                        value="Generate",
+                        variant="secondary",
+                        scale=1  # This makes it take up 1/4 of the row width
+                    )
+            with gr.Group():
+                with gr.Row():
+                    initial_system_message_input = gr.Textbox(
+                        label="Initial System Message",
+                        show_copy_button=True,
+                        value="",
+                        scale=4
+                    )
+                    evaluate_initial_system_message_button = gr.Button(
+                        value="Evaluate",
+                        variant="secondary",
+                        scale=1
+                    )
             recursion_limit_input = gr.Number(
-                label="Recursion Limit", value=config.recursion_limit,
-                precision=0, minimum=1, maximum=config.recursion_limit_max, step=1)
+                label="Recursion Limit",
+                value=config.recursion_limit,
+                precision=0,
+                minimum=1,
+                maximum=config.recursion_limit_max,
+                step=1
+            )
             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)
+                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],
+                value=list(config.prompt_templates.keys())[0]
             )
             with gr.Row():
                 with gr.Tabs():
@@ -658,13 +710,14 @@ with gr.Blocks(title='Meta Prompt') as demo:
                                             acceptance_criteria_input, initial_system_message_input],
                                 value='Clear All')
         with gr.Column():
-            system_message_output = gr.Textbox(
-                label="System Message", show_copy_button=True)
-            with gr.Row():
-                evaluate_system_message_button = gr.Button(
-                    value="Evaluate", variant="secondary")
-                copy_to_initial_system_message_button = gr.Button(
-                    value="Copy to Initial System Message", variant="secondary")
+            with gr.Group():
+                system_message_output = gr.Textbox(
+                    label="System Message", show_copy_button=True)
+                with gr.Row():
+                    evaluate_system_message_button = gr.Button(
+                        value="Evaluate", variant="secondary")
+                    copy_to_initial_system_message_button = gr.Button(
+                        value="Copy to Initial System Message", variant="secondary")
             output_output = gr.Textbox(label="Output", show_copy_button=True)
             analysis_output = gr.Textbox(
                 label="Analysis", show_copy_button=True)
@@ -693,6 +746,12 @@ with gr.Blocks(title='Meta Prompt') as demo:
     advanced_llm_tab.select(on_model_tab_select)
     expert_llm_tab.select(on_model_tab_select)
 
+    generate_acceptance_criteria_button.click(
+        generate_acceptance_criteria,
+        inputs=[user_message_input, expected_output_input, simple_model_name_input],
+        outputs=[acceptance_criteria_input]
+    )
+
     evaluate_initial_system_message_button.click(
         evaluate_system_message,
         inputs=[initial_system_message_input, user_message_input,

meta_prompt/consts.py

@@ -1,5 +1,7 @@
 from langchain_core.prompts import ChatPromptTemplate
 
+NODE_TASK_BRIEF_DEVELOPER = "task_brief_developer"
+NODE_ACCEPTANCE_CRITERIA_DEVELOPER = "acceptance_criteria_developer"
 NODE_PROMPT_INITIAL_DEVELOPER = "prompt_initial_developer"
 NODE_PROMPT_DEVELOPER = "prompt_developer"
 NODE_PROMPT_EXECUTOR = "prompt_executor"
@@ -8,6 +10,8 @@ NODE_PROMPT_ANALYZER = "prompt_analyzer"
 NODE_PROMPT_SUGGESTER = "prompt_suggester"
 
 META_PROMPT_NODES = [
+    NODE_TASK_BRIEF_DEVELOPER,
+    NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
     NODE_PROMPT_INITIAL_DEVELOPER,
     NODE_PROMPT_DEVELOPER,
     NODE_PROMPT_EXECUTOR,
@@ -17,6 +21,76 @@ META_PROMPT_NODES = [
 ]
 
 DEFAULT_PROMPT_TEMPLATES = {
+    NODE_TASK_BRIEF_DEVELOPER: ChatPromptTemplate.from_messages([
+        ("system", """# Task Brief Developer
+
+You are a task brief developer. You will receive a specific example to create a task brief. You will respond directly with the brief for the task type.
+
+## Instructions
+
+The user will provide you a specific example with User Message (input) and Expected Output (output) of a task type. You will respond with a brief for the task type in the following format:
+
+```
+# Task Description
+
+[Task description]
+```
+
+"""),
+        ("human", """# User Message
+
+{user_message}
+
+# Expected Output
+
+{expected_output}
+
+# Task Brief
+
+""")
+    ]),
+    NODE_ACCEPTANCE_CRITERIA_DEVELOPER: ChatPromptTemplate.from_messages([
+        ("system", """# Acceptance Criteria Developer
+
+You are an acceptance criteria developer. You will receive a specific example of a task type to create acceptance criteria. You will respond directly with the acceptance criteria.
+
+## Instructions
+
+The user will provide you a specific example with User Message (input) and Expected Output (output) of a task type. You will respond with acceptance criteria for the task type includes the following:
+
+* What the output should include
+* What the output should not include
+* Any specific formatting or structure requirements
+
+## Output
+
+Create acceptance criteria in the following format:
+
+```
+# Acceptance Criteria
+
+* [Criteria 1]
+* [Criteria 2]
+* [Criteria 3]
+```
+
+"""),
+        ("human", """# Task Brief
+
+{system_message}
+
+# User Message
+
+{user_message}
+
+# Expected Output
+
+{expected_output}
+
+# Acceptance Criteria
+
+""")
+    ]),
     NODE_PROMPT_INITIAL_DEVELOPER: ChatPromptTemplate.from_messages([
         ("system", """# Expert Prompt Engineer
 
@@ -28,7 +102,7 @@ The user will provide you a specific example to create the GPT. You will respond
 
 ## Output
 
-Create a [name], Here’s the descriptions [description]. Start with “GPT Description:”
+Create a [name], Here's the descriptions [description]. Start with "GPT Description:"
 """),
         ("human", """# User Message
             
@@ -56,7 +130,7 @@ The user will provide you a specific example (`User Message` and `Expected Outpu
 
 ## Output
 
-Create a [name], Here’s the descriptions [description]. Start with “GPT Description:”
+Create a [name], Here's the descriptions [description]. Start with "GPT Description:"
 """),
         ("human", """# Current System Message
 
@@ -216,4 +290,4 @@ Provide your analysis in the following format:
 <|End_Analysis|>
 """)
     ])
-}
+}

meta_prompt/meta_prompt.py

@@ -8,6 +8,7 @@ from langchain_core.prompts import ChatPromptTemplate
 from langgraph.graph import StateGraph, END
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.errors import GraphRecursionError
+from langchain_core.runnables.base import RunnableLike
 from pydantic import BaseModel
 from .consts import *
 
@@ -46,26 +47,30 @@ class MetaPromptGraph:
     """
     This class represents a graph for meta-prompting in a conversational AI system.
 
-    It manages the state of the conversation, including the user's message, expected output, 
-    acceptance criteria, system message, output, suggestions, and analysis. The graph 
-    consists of nodes that represent different stages of the conversation, such as 
-    prompting the developer, executing the output, analyzing the output history, and 
-    suggesting new prompts. The class provides methods to create the workflow, 
-    initialize the graph, and invoke the graph with a given state.
+    It manages the state of the conversation, including the user's message, expected 
+    output, acceptance criteria, system message, output, suggestions, and analysis.
 
-    The MetaPromptGraph class is responsible for orchestrating the conversation flow 
-    and deciding the next step based on the current state of the conversation. It uses 
-    language models and prompt templates to generate responses and analyze the output.
+    The graph consists of nodes that represent different stages of the conversation, 
+    such as prompting the developer, executing the output, analyzing the output 
+    history, and suggesting new prompts.
+
+    The class provides methods to create the workflow, initialize the graph, and 
+    invoke the graph with a given state.
+
+    The MetaPromptGraph class is responsible for orchestrating the conversation 
+    flow and deciding the next step based on the current state of the 
+    conversation. It uses language models and prompt templates to generate 
+    responses and analyze the output.
     """
     @classmethod
     def get_node_names(cls):
         """
         Returns a list of node names in the meta-prompt graph.
 
-        This method is used to initialize the language models and prompt templates for each node in the graph.
+        This method initializes language models and prompt templates for each node.
 
         Returns:
-            list: A list of node names.
+            list: List of node names.
         """
         return META_PROMPT_NODES
 
@@ -79,12 +84,18 @@ class MetaPromptGraph:
         Initializes the MetaPromptGraph instance.
 
         Args:
-        - llms (Union[BaseLanguageModel, Dict[str, BaseLanguageModel]], optional): The language models for the graph nodes. Defaults to {}.
-        - prompts (Dict[str, ChatPromptTemplate], optional): The custom prompt templates for the graph nodes. Defaults to {}.
-        - logger (Optional[logging.Logger], optional): The logger for the graph. Defaults to None.
-        - verbose (bool, optional): Whether to set the logger level to DEBUG. Defaults to False.
-
-        Initializes the logger, sets the language models and prompt templates for the graph nodes, and updates the prompt templates with custom ones if provided.
+        - llms (Union[BaseLanguageModel, Dict[str, BaseLanguageModel]], 
+            optional): The language models for the graph nodes. Defaults to {}.
+        - prompts (Dict[str, ChatPromptTemplate], optional): The custom 
+            prompt templates for the graph nodes. Defaults to {}.
+        - logger (Optional[logging.Logger], optional): The logger for 
+            the graph. Defaults to None.
+        - verbose (bool, optional): Whether to set the logger level to 
+            DEBUG. Defaults to False.
+
+        Initializes the logger, sets the language models and prompt 
+        templates for the graph nodes, and updates the prompt templates 
+        with custom ones if provided.
         """
         self.logger = logger or logging.getLogger(__name__)
         if self.logger is not None:
@@ -94,6 +105,7 @@ class MetaPromptGraph:
                 self.logger.setLevel(logging.INFO)
 
         if isinstance(llms, BaseLanguageModel):
+            # if llms is a single language model, wrap it in a dictionary
             self.llms: Dict[str, BaseLanguageModel] = {
                 node: llms for node in self.get_node_names()}
         else:
@@ -102,7 +114,29 @@ class MetaPromptGraph:
                                     ChatPromptTemplate] = DEFAULT_PROMPT_TEMPLATES.copy()
         self.prompt_templates.update(prompts)
 
+
+    def _create_acceptance_criteria_workflow(self) -> StateGraph:
+        workflow = StateGraph(AgentState)
+        workflow.add_node(NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
+                          lambda x: self._prompt_node(
+                              NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
+                              "acceptance_criteria",
+                              x))
+        workflow.add_edge(NODE_ACCEPTANCE_CRITERIA_DEVELOPER, END)
+        workflow.set_entry_point(NODE_ACCEPTANCE_CRITERIA_DEVELOPER)
+        return workflow
+
+
     def _create_workflow(self, including_initial_developer: bool = True) -> StateGraph:
+        """Create a workflow state graph.
+
+        Args:
+            including_initial_developer: Flag indicating whether to include the 
+                initial developer node in the workflow.
+
+        Returns:
+            StateGraph: A state graph representing the workflow.
+        """
         workflow = StateGraph(AgentState)
 
         workflow.add_node(NODE_PROMPT_DEVELOPER,
@@ -125,10 +159,12 @@ class MetaPromptGraph:
                               "suggestions",
                               x))
 
+        # Connect nodes
         workflow.add_edge(NODE_PROMPT_DEVELOPER, NODE_PROMPT_EXECUTOR)
         workflow.add_edge(NODE_PROMPT_EXECUTOR, NODE_OUTPUT_HISTORY_ANALYZER)
         workflow.add_edge(NODE_PROMPT_SUGGESTER, NODE_PROMPT_DEVELOPER)
 
+        # Add conditional edges
         workflow.add_conditional_edges(
             NODE_OUTPUT_HISTORY_ANALYZER,
             lambda x: self._should_exit_on_max_age(x),
@@ -148,6 +184,7 @@ class MetaPromptGraph:
             }
         )
 
+        # Set entry point based on including_initial_developer flag
         if including_initial_developer:
             workflow.add_node(NODE_PROMPT_INITIAL_DEVELOPER,
                               lambda x: self._prompt_node(
@@ -161,8 +198,40 @@ class MetaPromptGraph:
             workflow.set_entry_point(NODE_PROMPT_EXECUTOR)
 
         return workflow
+    
+    def run_acceptance_criteria_graph(self, state: AgentState, recursion_limit: int = 25) -> AgentState:
+        self.logger.debug("Creating acceptance criteria workflow")
+        workflow = self._create_acceptance_criteria_workflow()
+        self.logger.debug("Compiling workflow with memory saver")
+        memory = MemorySaver()
+        graph = workflow.compile(checkpointer=memory)
+        self.logger.debug("Configuring graph with recursion limit %s", recursion_limit)
+        config = {"configurable": {"thread_id": "1"},
+                  "recursion_limit": recursion_limit}
+        self.logger.debug("Invoking graph with state: %s", pprint.pformat(state))
+        output_state = graph.invoke(state, config)
+        self.logger.debug("Output state: %s", pprint.pformat(output_state))
+        return output_state
+    
 
-    def __call__(self, state: AgentState, recursion_limit: int = 25) -> AgentState:
+    def run_meta_prompt_graph(self, state: AgentState, recursion_limit: int = 25) -> AgentState:
+        """
+        Invoke the meta-prompt workflow with the given state and recursion limit.
+
+        This method creates a workflow based on the presence of an initial system
+        message, compiles the workflow with a memory saver, and invokes the graph
+        with the given state. If a recursion limit is reached, it returns the best
+        state found so far.
+
+        Parameters:
+            state (AgentState): The current state of the agent, containing
+                necessary context for message formatting.
+            recursion_limit (int): The maximum number of recursive calls
+                allowed. Defaults to 25.
+
+        Returns:
+            AgentState: The output state of the agent after invoking the workflow.
+        """
         workflow = self._create_workflow(including_initial_developer=(
             state.system_message is None or state.system_message == ""))
 
@@ -195,20 +264,48 @@ class MetaPromptGraph:
 
         return state
 
+
+    def __call__(self, state: AgentState, recursion_limit: int = 25) -> AgentState:
+        return self.run_meta_prompt_graph(state, recursion_limit)
+
+
+    def _optional_action(
+        self, target_attribute: str,
+        action: Optional[RunnableLike],
+        state: AgentState
+    ) -> AgentState:
+        """
+        Optionally invokes an action if the target attribute is not set or empty.
+
+        Args:
+            node (str): Node identifier.
+            target_attribute (str): State attribute to be updated.
+            action (Optional[RunnableLike]): Action to be invoked. Defaults to None.
+            state (AgentState): Current agent state.
+
+        Returns:
+            AgentState: Updated state.
+        """
+        if not getattr(state, target_attribute, None) or getattr(state, target_attribute) == "":
+            if action:
+                state = action(state)
+        return state
+    
+
     def _prompt_node(self, node, target_attribute: str, state: AgentState) -> AgentState:
         """
         Prompt a specific node with the given state and update the state with the response.
 
-        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.
+        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.
+            node (str): Node identifier to be prompted.
+            target_attribute (str): State attribute to be updated with response content.
+            state (AgentState): Current agent state with necessary context for message formatting.
 
         Returns:
-            AgentState: The updated state of the agent with the response content set to the target attribute.
+            AgentState: Updated state with response content set to the target attribute.
         """
 
         logger = self.logger.getChild(node)
@@ -234,47 +331,77 @@ class MetaPromptGraph:
         return state
 
     def _output_history_analyzer(self, state: AgentState) -> AgentState:
+        """
+        Analyzes the output history and updates the best output and its age.
+
+        This method checks if the best output is initialized, formats the prompt for
+        the output history analyzer, invokes the language model, and updates the best
+        output and its age based on the response.
+
+        Parameters:
+            state (AgentState): Current state of the agent with necessary context
+                for message formatting.
+
+        Returns:
+            AgentState: Updated state with the best output and its age.
+        """
         logger = self.logger.getChild(NODE_OUTPUT_HISTORY_ANALYZER)
 
         if state.best_output is None:
             state.best_output = state.output
             state.best_system_message = state.system_message
             state.best_output_age = 0
-
             logger.debug(
                 "Best output initialized to the current output:\n%s", state.output)
-
             return state
 
         prompt = self.prompt_templates[NODE_OUTPUT_HISTORY_ANALYZER].format_messages(
             **state.model_dump())
 
         for message in prompt:
-            logger.debug({'node': NODE_OUTPUT_HISTORY_ANALYZER, 'action': 'invoke',
-                         'type': message.type, 'message': message.content})
+            logger.debug({
+                'node': NODE_OUTPUT_HISTORY_ANALYZER,
+                'action': 'invoke',
+                'type': message.type,
+                'message': message.content
+            })
 
         response = self.llms[NODE_OUTPUT_HISTORY_ANALYZER].invoke(prompt)
-        logger.debug({'node': NODE_OUTPUT_HISTORY_ANALYZER, 'action': 'response',
-                     'type': response.type, 'message': response.content})
+        logger.debug({
+            'node': NODE_OUTPUT_HISTORY_ANALYZER,
+            'action': 'response',
+            'type': response.type,
+            'message': response.content
+        })
 
         analysis = response.content
 
-        if state.best_output is None or "# Output ID closer to Expected Output: B" in analysis:
+        if state.best_output is None or (
+                "# Output ID closer to Expected Output: B" in analysis):
             state.best_output = state.output
             state.best_system_message = state.system_message
             state.best_output_age = 0
-
             logger.debug(
                 "Best output updated to the current output:\n%s", state.output)
         else:
             state.best_output_age += 1
-
-            logger.debug("Best output age incremented to %s",
-                         state.best_output_age)
+            logger.debug("Best output age incremented to %s", state.best_output_age)
 
         return state
 
     def _prompt_analyzer(self, state: AgentState) -> AgentState:
+        """
+        Analyzes the prompt and updates the state with the analysis and 
+        acceptance status.
+
+        Args:
+            state (AgentState): The current state of the agent, containing 
+                necessary context for message formatting.
+
+        Returns:
+            AgentState: The updated state of the agent with the analysis 
+                and acceptance status.
+        """
         logger = self.logger.getChild(NODE_PROMPT_ANALYZER)
         prompt = self.prompt_templates[NODE_PROMPT_ANALYZER].format_messages(
             **state.model_dump())
@@ -295,6 +422,15 @@ class MetaPromptGraph:
         return state
 
     def _should_exit_on_max_age(self, state: AgentState) -> str:
+        """
+        Determines whether to exit the workflow based on the maximum output age.
+
+        Args:
+            state (AgentState): The current state of the agent.
+
+        Returns:
+            str: The decision to continue, rerun, or end the workflow.
+        """
         if state.max_output_age <= 0:
             # always continue if max age is 0
             return "continue"
@@ -309,4 +445,13 @@ class MetaPromptGraph:
         return "continue"
 
     def _should_exit_on_acceptable_output(self, state: AgentState) -> str:
+        """
+        Determines whether to exit the workflow based on the acceptance status of the output.
+
+        Args:
+            state (AgentState): The current state of the agent.
+
+        Returns:
+            str: The decision to continue or end the workflow.
+        """
         return "continue" if not state.accepted else END

tests/meta_prompt_graph_test.py

@@ -8,6 +8,8 @@ from langchain_openai import ChatOpenAI
 
 # Assuming the necessary imports are made for the classes and functions used in meta_prompt_graph.py
 from meta_prompt import *
+from meta_prompt.consts import NODE_ACCEPTANCE_CRITERIA_DEVELOPER
+from langgraph.graph import StateGraph, END
 
 class TestMetaPromptGraph(unittest.TestCase):
     def setUp(self):
@@ -274,6 +276,69 @@ class TestMetaPromptGraph(unittest.TestCase):
 
         pprint.pp(output_state["best_output"])
 
+    def test_create_acceptance_criteria_workflow(self):
+        """
+        Test the _create_acceptance_criteria_workflow method of MetaPromptGraph.
+
+        This test case verifies that the workflow created by the _create_acceptance_criteria_workflow method
+        contains the correct node and edge.
+        """
+
+        llms = {
+            NODE_ACCEPTANCE_CRITERIA_DEVELOPER: ChatOpenAI(model_name="deepseek/deepseek-chat")
+        }
+        meta_prompt_graph = MetaPromptGraph(llms=llms)
+        workflow = meta_prompt_graph._create_acceptance_criteria_workflow()
+
+        # Check if the workflow contains the correct node
+        self.assertIn(NODE_ACCEPTANCE_CRITERIA_DEVELOPER, workflow.nodes)
+
+        # Check if the workflow contains the correct edge
+        self.assertIn((NODE_ACCEPTANCE_CRITERIA_DEVELOPER, END), workflow.edges)
+
+        # compile the workflow
+        graph = workflow.compile()
+        print(graph)
+
+        # invoke the workflow
+        state = AgentState(
+            user_message="How do I reverse a list in Python?",
+            expected_output="The output should use the `reverse()` method.",
+            # system_message="Create acceptance criteria for the task of reversing a list in Python."
+        )
+        output_state = graph.invoke(state)
+
+        # check if the output state contains the acceptance criteria
+        self.assertIsNotNone(output_state['acceptance_criteria'])
+
+        # check if the acceptance criteria includes string '`reverse()`'
+        self.assertIn('`reverse()`', output_state['acceptance_criteria'])
+
+        pprint.pp(output_state["acceptance_criteria"])
+
+    def test_run_acceptance_criteria_graph(self):
+        """
+        Test the run_acceptance_criteria_graph method of MetaPromptGraph.
+
+        This test case verifies that the run_acceptance_criteria_graph method returns a state with acceptance criteria.
+        """
+        llms = {
+            NODE_ACCEPTANCE_CRITERIA_DEVELOPER: MagicMock(
+                invoke=lambda prompt: MagicMock(content="Acceptance criteria: ..."))
+        }
+        meta_prompt_graph = MetaPromptGraph(llms=llms)
+        state = AgentState(
+            user_message="How do I reverse a list in Python?",
+            expected_output="The output should use the `reverse()` method.",
+        )
+        output_state = meta_prompt_graph.run_acceptance_criteria_graph(state)
+
+        # Check if the output state contains the acceptance criteria
+        self.assertIsNotNone(output_state['acceptance_criteria'])
+
+        # Check if the acceptance criteria includes the expected content
+        self.assertIn("Acceptance criteria: ...", output_state['acceptance_criteria'])
+
 
 if __name__ == '__main__':
     unittest.main()