Acceptance Criteria generating works now.

app/gradio_meta_prompt.py

@@ -181,38 +181,39 @@ 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, expert_model_config: Optional[Dict[str, Any]] = None) -> BaseLanguageModel:
+def get_current_model(simple_model_name: str,
+                        advanced_model_name: str,
+                        expert_model_name: str,
+                        expert_model_config: Optional[Dict[str, Any]] = None) -> BaseLanguageModel:
     """
     Retrieve and return a language model (LLM) based on the currently active model tab.
 
-    This function uses a mapping to associate model tab names with their corresponding model names.
-    It then looks up the configuration for the selected executor model in the application's
-    configuration, creates an instance of the appropriate type of language model using that
-    configuration, and returns it. If the active model tab is not found in the mapping, the simple model
-    will be used as a default.
+    This function uses a mapping to associate model tab names with their corresponding
+    model names. It then looks up the configuration for the selected model in the
+    application's configuration, creates an instance of the appropriate type of language
+    model using that configuration, and returns it. If the active model tab is not found
+    in the mapping, the simple model will be used as a default.
 
     Args:
-        simple_model_name (str): The name of the simple language model.
-            This should correspond to a key in the 'llms' section of the application's configuration.
-        advanced_model_name (str): The name of the advanced language model.
-            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_config (Optional[Dict[str, Any]]): Optional configuration for the expert model.
-            This configuration will be used to update the executor model configuration if the active
-            model tab is "Expert". Defaults to None.
+        simple_model_name (str): The name of the simple language model. This should
+            correspond to a key in the 'llms' section of the application's configuration.
+        advanced_model_name (str): The name of the advanced language model. 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_config (Optional[Dict[str, Any]]): Optional configuration for the
+            expert model. This configuration will be used to update the 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.
+        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.
-
+        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 model.
     """
     model_mapping = {
         "Simple": simple_model_name,
@@ -221,16 +222,16 @@ def get_current_executor_model(simple_model_name: str,
     }
     
     try:
-        executor_model_name = model_mapping.get(active_model_tab, simple_model_name)
-        executor_model = config.llms[executor_model_name]
-        executor_model_type = executor_model.type
-        executor_model_config = executor_model.model_dump(exclude={'type'})
+        model_name = model_mapping.get(active_model_tab, simple_model_name)
+        model = config.llms[model_name]
+        model_type = model.type
+        model_config = model.model_dump(exclude={'type'})
     
         # Update the configuration with the expert model configurations if provided
         if active_model_tab == "Expert" and expert_model_config:
-            executor_model_config.update(expert_model_config)
+            model_config.update(expert_model_config)
     
-        return LLMModelFactory().create(executor_model_type, **executor_model_config)
+        return LLMModelFactory().create(model_type, **model_config)
     
     except KeyError as e:
         logging.error(f"Configuration key error: {e}")
@@ -238,7 +239,7 @@ def get_current_executor_model(simple_model_name: str,
     
     except Exception as e:
         logging.error(f"An unexpected error occurred: {e}")
-        raise RuntimeError(f"Failed to retrieve the executor model: {e}")
+        raise RuntimeError(f"Failed to retrieve the model: {e}")
 
 
 def evaluate_system_message(system_message, user_message,
@@ -265,7 +266,7 @@ def evaluate_system_message(system_message, user_message,
         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,
+    llm = get_current_model(simple_model,
                                      advanced_executor_model,
                                      expert_executor_model, {"temperature": expert_execuor_model_temperature})
     template = ChatPromptTemplate.from_messages([
@@ -282,6 +283,142 @@ def evaluate_system_message(system_message, user_message,
         raise gr.Error(f"Error: {e}")
 
 
+def generate_acceptance_criteria(user_message, expected_output,
+                                 simple_model, advanced_executor_model,
+                                 expert_prompt_acceptance_criteria_model,
+                                 expert_prompt_acceptance_criteria_temperature=0.1,
+                                 prompt_template_group: Optional[str] = None):
+    """
+    Generate acceptance criteria based on the user message and expected output.
+
+    This function uses the MetaPromptGraph's run_acceptance_criteria_graph method
+    to generate acceptance criteria.
+
+    Args:
+        user_message (str): The user's input message.
+        expected_output (str): The anticipated response or outcome from the language
+            model based on the user's message.
+        simple_model (str): The name of the simple language model.
+        advanced_executor_model (str): The name of the advanced language model.
+        expert_prompt_acceptance_criteria_model (str): The name of the expert language
+            model.
+        expert_prompt_acceptance_criteria_temperature (float, optional): The temperature
+            parameter for the expert model. Defaults to 0.1.
+        prompt_template_group (Optional[str], optional): The group of prompt templates
+            to use. Defaults to None.
+
+    Returns:
+        str: The generated acceptance criteria.
+    """
+
+    log_stream = io.StringIO()
+    logger = logging.getLogger(MetaPromptGraph.__name__) if config.verbose else None
+    log_handler = logging.StreamHandler(log_stream) if logger else None
+
+    if log_handler:
+        log_handler.setFormatter(
+            jsonlogger.JsonFormatter('%(asctime)s %(name)s %(levelname)s %(message)s')
+        )
+        logger.addHandler(log_handler)
+
+    llm = get_current_model(simple_model, advanced_executor_model,
+                            expert_prompt_acceptance_criteria_model,
+                            {"temperature": expert_prompt_acceptance_criteria_temperature})
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(
+        config.prompt_templates[prompt_template_group]
+    )
+    acceptance_criteria_graph = MetaPromptGraph(llms={
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: llm
+    }, prompts=prompt_templates,
+    verbose=config.verbose, logger=logger)
+    state = AgentState(
+        user_message=user_message,
+        expected_output=expected_output
+    )
+    output_state = acceptance_criteria_graph.run_acceptance_criteria_graph(state)
+
+    if log_handler:
+        log_handler.close()
+        log_output = log_stream.getvalue()
+    else:
+        log_output = None
+    return output_state.get('acceptance_criteria', ""), chat_log_2_chatbot_list(log_output)
+
+
+def generate_initial_system_message(
+    user_message: str,
+    expected_output: str,
+    simple_model: str,
+    advanced_executor_model: str,
+    expert_prompt_initial_developer_model: str,
+    expert_prompt_initial_developer_temperature: float = 0.1,
+    prompt_template_group: Optional[str] = None
+) -> tuple:
+    """
+    Generate an initial system message based on the user message and expected output.
+
+    Args:
+        user_message (str): The user's input message.
+        expected_output (str): The anticipated response or outcome from the language model.
+        simple_model (str): The name of the simple language model.
+        advanced_executor_model (str): The name of the advanced language model.
+        expert_prompt_initial_developer_model (str): The name of the expert language model.
+        expert_prompt_initial_developer_temperature (float, optional): The temperature parameter for the expert model. Defaults to 0.1.
+        prompt_template_group (Optional[str], optional): The group of prompt templates to use. Defaults to None.
+
+    Returns:
+        tuple: A tuple containing the initial system message and the chat log.
+    """
+
+    log_stream = io.StringIO()
+    logger = logging.getLogger(MetaPromptGraph.__name__) if config.verbose else None
+    log_handler = logging.StreamHandler(log_stream) if logger else None
+
+    if log_handler:
+        log_handler.setFormatter(
+            jsonlogger.JsonFormatter('%(asctime)s %(name)s %(levelname)s %(message)s')
+        )
+        logger.addHandler(log_handler)
+
+    llm = get_current_model(
+        simple_model,
+        advanced_executor_model,
+        expert_prompt_initial_developer_model,
+        {"temperature": expert_prompt_initial_developer_temperature}
+    )
+
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(
+        config.prompt_templates[prompt_template_group]
+    )
+
+    initial_system_message_graph = MetaPromptGraph(
+        llms={NODE_PROMPT_INITIAL_DEVELOPER: llm},
+        prompts=prompt_templates,
+        verbose=config.verbose,
+        logger=logger
+    )
+
+    state = AgentState(
+        user_message=user_message,
+        expected_output=expected_output
+    )
+
+    output_state = initial_system_message_graph.run_prompt_initial_developer_graph(state)
+
+    if log_handler:
+        log_handler.close()
+        log_output = log_stream.getvalue()
+    else:
+        log_output = None
+
+    system_message = output_state.get('system_message', "")
+    return system_message, chat_log_2_chatbot_list(log_output)
+
+
 def process_message(user_message: str, expected_output: str,
                     acceptance_criteria: str, initial_system_message: str,
                     recursion_limit: int, max_output_age: int,
@@ -464,6 +601,7 @@ def process_message_with_2_llms(user_message: str, expected_output: str,
     optimizer_model = initialize_llm(optimizer_model_name)
     executor_model = initialize_llm(executor_model_name)
     llms = {
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: optimizer_model,
         NODE_PROMPT_INITIAL_DEVELOPER: optimizer_model,
         NODE_PROMPT_DEVELOPER: optimizer_model,
         NODE_PROMPT_EXECUTOR: executor_model,
@@ -479,6 +617,7 @@ 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,
+                                     acceptance_criteria_model_name: str, acceptance_criteria_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,
@@ -488,6 +627,7 @@ def process_message_with_expert_llms(user_message: str, expected_output: str,
 
     llms = {
         NODE_PROMPT_INITIAL_DEVELOPER: initialize_llm(initial_developer_model_name, {"temperature": initial_developer_temperature}),
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: initialize_llm(acceptance_criteria_model_name, {"temperature": acceptance_criteria_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}),
@@ -498,25 +638,6 @@ 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
 
@@ -554,29 +675,28 @@ with gr.Blocks(title='Meta Prompt') as demo:
                 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
-                    )
+                acceptance_criteria_input = gr.Textbox(
+                    label="Acceptance Criteria (Compared with Expected Output [EO])",
+                    show_copy_button=True
+                )
+                generate_acceptance_criteria_button = gr.Button(
+                    value="Generate",
+                    variant="secondary"
+                )
             with gr.Group():
+                initial_system_message_input = gr.Textbox(
+                    label="Initial System Message",
+                    show_copy_button=True,
+                    value=""
+                )
                 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
+                        variant="secondary"
+                    )
+                    generate_initial_system_message_button = gr.Button(
+                        value="Generate",
+                        variant="secondary"
                     )
             recursion_limit_input = gr.Number(
                 label="Recursion Limit",
@@ -600,7 +720,7 @@ with gr.Blocks(title='Meta Prompt') as demo:
                 value=list(config.prompt_templates.keys())[0]
             )
             with gr.Row():
-                with gr.Tabs():
+                with gr.Tabs() as llm_tabs:
                     with gr.Tab('Simple') as simple_llm_tab:
                         simple_model_name_input = gr.Dropdown(
                             label="Model Name",
@@ -646,6 +766,17 @@ with gr.Blocks(title='Meta Prompt') as demo:
                                 precision=1, minimum=0, maximum=1, step=0.1,
                                 interactive=True)
 
+                        with gr.Row():
+                            expert_prompt_acceptance_criteria_model_name_input = gr.Dropdown(
+                                label="Acceptance Criteria Model Name",
+                                choices=config.llms.keys(),
+                                value=list(config.llms.keys())[0],
+                            )
+                            expert_prompt_acceptance_criteria_temperature_input = gr.Number(
+                                label="Acceptance Criteria Temperature", value=0.1,
+                                precision=1, minimum=0, maximum=1, step=0.1,
+                                interactive=True)
+
                         with gr.Row():
                             expert_prompt_developer_model_name_input = gr.Dropdown(
                                 label="Developer Model Name",
@@ -748,8 +879,21 @@ with gr.Blocks(title='Meta Prompt') as demo:
 
     generate_acceptance_criteria_button.click(
         generate_acceptance_criteria,
-        inputs=[user_message_input, expected_output_input, simple_model_name_input],
-        outputs=[acceptance_criteria_input]
+        inputs=[user_message_input, expected_output_input,
+                simple_model_name_input,
+                advanced_optimizer_model_name_input,
+                expert_prompt_acceptance_criteria_model_name_input, expert_prompt_acceptance_criteria_temperature_input],
+        outputs=[acceptance_criteria_input, logs_chatbot]
+    )
+    generate_initial_system_message_button.click(
+        generate_initial_system_message,
+        inputs=[user_message_input, expected_output_input,
+                simple_model_name_input,
+                advanced_optimizer_model_name_input,
+                expert_prompt_initial_developer_model_name_input,
+                expert_prompt_initial_developer_temperature_input,
+                prompt_template_group],
+        outputs=[initial_system_message_input, logs_chatbot]
     )
 
     evaluate_initial_system_message_button.click(
@@ -830,6 +974,7 @@ with gr.Blocks(title='Meta Prompt') as demo:
             recursion_limit_input,
             max_output_age,
             expert_prompt_initial_developer_model_name_input, expert_prompt_initial_developer_temperature_input,
+            expert_prompt_acceptance_criteria_model_name_input, expert_prompt_acceptance_criteria_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,

meta_prompt/__init__.py

@@ -3,6 +3,7 @@ __version__ = '0.1.0'
 from .meta_prompt import AgentState, MetaPromptGraph
 from .consts import (
     META_PROMPT_NODES,
+    NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
     NODE_PROMPT_INITIAL_DEVELOPER,
     NODE_PROMPT_DEVELOPER,
     NODE_PROMPT_EXECUTOR,

meta_prompt/consts.py

@@ -1,6 +1,6 @@
 from langchain_core.prompts import ChatPromptTemplate
 
-NODE_TASK_BRIEF_DEVELOPER = "task_brief_developer"
+# 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"
@@ -10,7 +10,7 @@ NODE_PROMPT_ANALYZER = "prompt_analyzer"
 NODE_PROMPT_SUGGESTER = "prompt_suggester"
 
 META_PROMPT_NODES = [
-    NODE_TASK_BRIEF_DEVELOPER,
+#     NODE_TASK_BRIEF_DEVELOPER,
     NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
     NODE_PROMPT_INITIAL_DEVELOPER,
     NODE_PROMPT_DEVELOPER,
@@ -21,34 +21,35 @@ META_PROMPT_NODES = [
 ]
 
 DEFAULT_PROMPT_TEMPLATES = {
-    NODE_TASK_BRIEF_DEVELOPER: ChatPromptTemplate.from_messages([
-        ("system", """# Task Brief Developer
+#     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.
+# 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
+# ## 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:
+# 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
 
-[Task description]
-```
+# [Task description]
+# ```
 
-"""),
-        ("human", """# User Message
+# """),
+#         ("human", """# User Message
 
-{user_message}
+# {user_message}
 
-# Expected Output
+# # Expected Output
 
-{expected_output}
+# {expected_output}
 
-# Task Brief
+# # Task Brief
+
+# """)
+#     ]),
 
-""")
-    ]),
     NODE_ACCEPTANCE_CRITERIA_DEVELOPER: ChatPromptTemplate.from_messages([
         ("system", """# Acceptance Criteria Developer
 
@@ -56,11 +57,15 @@ You are an acceptance criteria developer. You will receive a specific example of
 
 ## 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:
+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, by comparing with Expected Output (which may be referenced as EO), includes the following:
 
 * What the output should include
 * What the output should not include
-* Any specific formatting or structure requirements
+* Language requirements
+* Formatting requirements
+* Structure requirements
+* Style requirements
+* Any specific requirements
 
 ## Output
 
@@ -68,10 +73,14 @@ Create acceptance criteria in the following format:
 
 ```
 # Acceptance Criteria
-
+         
 * [Criteria 1]
 * [Criteria 2]
-* [Criteria 3]
+* ...
+* Unacceptable differences (comapire with EO):
+  * ...
+* Acceptable differences (comapire with EO):
+  * ...
 ```
 
 """),

meta_prompt/meta_prompt.py

@@ -127,7 +127,19 @@ class MetaPromptGraph:
         return workflow
 
 
-    def _create_workflow(self, including_initial_developer: bool = True) -> StateGraph:
+    def _create_prompt_initial_developer_workflow(self) -> StateGraph:
+        workflow = StateGraph(AgentState)
+        workflow.add_node(NODE_PROMPT_INITIAL_DEVELOPER,
+                          lambda x: self._prompt_node(
+                              NODE_PROMPT_INITIAL_DEVELOPER,
+                              "system_message",
+                              x))
+        workflow.add_edge(NODE_PROMPT_INITIAL_DEVELOPER, END)
+        workflow.set_entry_point(NODE_PROMPT_INITIAL_DEVELOPER)
+        return workflow
+
+
+    def _create_workflow(self) -> StateGraph:
         """Create a workflow state graph.
 
         Args:
@@ -184,30 +196,61 @@ class MetaPromptGraph:
             }
         )
 
-        # Set entry point based on including_initial_developer flag
-        if including_initial_developer:
-            workflow.add_node(NODE_PROMPT_INITIAL_DEVELOPER,
+        # # 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(
+        #                           NODE_PROMPT_INITIAL_DEVELOPER,
+        #                           "system_message",
+        #                           x))
+        #     workflow.add_edge(NODE_PROMPT_INITIAL_DEVELOPER,
+        #                       NODE_PROMPT_EXECUTOR)
+        #     workflow.set_entry_point(NODE_PROMPT_INITIAL_DEVELOPER)
+        # else:
+        #     workflow.set_entry_point(NODE_PROMPT_EXECUTOR)
+
+        workflow.add_node(NODE_PROMPT_INITIAL_DEVELOPER,
+                          lambda x: self._optional_action(
+                              "system_message",
                               lambda x: self._prompt_node(
                                   NODE_PROMPT_INITIAL_DEVELOPER,
                                   "system_message",
-                                  x))
-            workflow.add_edge(NODE_PROMPT_INITIAL_DEVELOPER,
-                              NODE_PROMPT_EXECUTOR)
-            workflow.set_entry_point(NODE_PROMPT_INITIAL_DEVELOPER)
-        else:
-            workflow.set_entry_point(NODE_PROMPT_EXECUTOR)
+                                  x),
+                              x))
+        workflow.add_node(NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
+                          lambda x: self._optional_action(
+                              "acceptance_criteria",
+                              lambda x: self._prompt_node(
+                                  NODE_ACCEPTANCE_CRITERIA_DEVELOPER,
+                                  "acceptance_criteria",
+                                  x),
+                              x))
+
+        workflow.add_edge(NODE_PROMPT_INITIAL_DEVELOPER, NODE_ACCEPTANCE_CRITERIA_DEVELOPER)
+        workflow.add_edge(NODE_ACCEPTANCE_CRITERIA_DEVELOPER, NODE_PROMPT_EXECUTOR)
+        workflow.set_entry_point(NODE_PROMPT_INITIAL_DEVELOPER)
 
         return workflow
+
     
-    def run_acceptance_criteria_graph(self, state: AgentState, recursion_limit: int = 25) -> AgentState:
+    def run_acceptance_criteria_graph(self, state: AgentState) -> 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}
+        config = {"configurable": {"thread_id": "1"}}
+        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 run_prompt_initial_developer_graph(self, state: AgentState) -> AgentState:
+        self.logger.debug("Creating prompt initial developer workflow")
+        workflow = self._create_prompt_initial_developer_workflow()
+        memory = MemorySaver()
+        graph = workflow.compile(checkpointer=memory)
+        config = {"configurable": {"thread_id": "1"}}
         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))
@@ -232,8 +275,7 @@ class MetaPromptGraph:
         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 == ""))
+        workflow = self._create_workflow()
 
         memory = MemorySaver()
         graph = workflow.compile(checkpointer=memory)
@@ -271,7 +313,7 @@ class MetaPromptGraph:
 
     def _optional_action(
         self, target_attribute: str,
-        action: Optional[RunnableLike],
+        action: RunnableLike,
         state: AgentState
     ) -> AgentState:
         """
@@ -280,7 +322,7 @@ class MetaPromptGraph:
         Args:
             node (str): Node identifier.
             target_attribute (str): State attribute to be updated.
-            action (Optional[RunnableLike]): Action to be invoked. Defaults to None.
+            action (RunnableLike): Action to be invoked. Defaults to None.
             state (AgentState): Current agent state.
 
         Returns:

tests/meta_prompt_graph_test.py

@@ -316,6 +316,7 @@ class TestMetaPromptGraph(unittest.TestCase):
 
         pprint.pp(output_state["acceptance_criteria"])
 
+
     def test_run_acceptance_criteria_graph(self):
         """
         Test the run_acceptance_criteria_graph method of MetaPromptGraph.
@@ -340,5 +341,26 @@ class TestMetaPromptGraph(unittest.TestCase):
         self.assertIn("Acceptance criteria: ...", output_state['acceptance_criteria'])
 
 
+    def test_run_prompt_initial_developer_graph(self):
+        """
+        Test the run_prompt_initial_developer_graph method of MetaPromptGraph.
+
+        This test case verifies that the run_prompt_initial_developer_graph method returns a state with an initial developer prompt.
+        """
+        llms = {
+            NODE_PROMPT_INITIAL_DEVELOPER: MagicMock(
+                invoke=lambda prompt: MagicMock(content="Initial developer prompt: ..."))
+        }
+        meta_prompt_graph = MetaPromptGraph(llms=llms)
+        state = AgentState(user_message="How do I reverse a list in Python?")
+        output_state = meta_prompt_graph.run_prompt_initial_developer_graph(state)
+
+        # Check if the output state contains the initial developer prompt
+        self.assertIsNotNone(output_state['system_message'])
+
+        # Check if the initial developer prompt includes the expected content
+        self.assertIn("Initial developer prompt: ...", output_state['system_message'])
+
+
 if __name__ == '__main__':
     unittest.main()