Implement remaining CF Flows.

CF_CodeCriticWrongAttemptWithPlan.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class CF_CodeCriticWrongAttemptWithPlan(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_CodeCriticWrongAttemptWithPlan.yaml

@@ -0,0 +1,97 @@
+name: "CodeCriticWrongAttempt_Flow"
+description: |2-
+  Given a problem description, a correct solution strategy, and an incorrect solution candidate, provide useful feedback for correcting the mistakes in the solution. 
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+  - "testing_results_summary"
+  - "code"
+  - "plan"
+
+input_interface_initialized:
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to identify the issues with an incorrect competitive programming solution attempt.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - input description
+      - output description
+      - example test cases
+      - (optional) explanation of the test cases
+      - an incorrect Python solution attempt and a description of its issue
+
+    Additionally, the user will provide you with a conceptual solution to the problem which should guide your reasoning.
+
+    Crucially, your goal is to consider all aspects of the problem and pinpoint the issues with the solution attempt, and not to provide the code implementation yourself.
+    Some aspects to consider: Is the input correctly parsed? Is the output correctly formatted? Is the code implementation consistent with the conceptual solution? Are the corner cases correctly handled? Is there a logical mistake with the algorithm itself?
+    Use the code execution results provided in the issue description to guide your reasoning/debugging.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    # Input description
+    {{input_description}}
+
+    # Output description
+    {{output_description}}
+
+    {{io_examples_and_explanation}}
+    
+    # Conceptual solution
+    {{plan}}
+    
+    # Solution attempt to be fixed
+    ```python
+    {{code}}
+    ```
+
+    {{testing_results_summary}}
+
+
+    Consider the problem statement, the conceptual solution, the code implementation and the issue. Why is the solution attempt incorrect? How should it be fixed? Explain your reasoning very concisely, and do not provide code.
+  input_variables:
+    - "problem_description"
+    - "input_description"
+    - "output_description"
+    - "io_examples_and_explanation"
+    - "plan"
+    - "code"
+    - "testing_results_summary"
+  template_format: jinja2

CF_CodeDebugCollabWithPlan.py

@@ -0,0 +1,12 @@
+from flows.base_flows import CircularFlow
+
+
+class CF_CodeDebugCollabWithPlan(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _early_exit(self):
+        if self.flow_state.get("all_tests_passed", False):
+            return True
+
+        return super()._early_exit()

CF_CodeDebugCollabWithPlan.yaml

@@ -0,0 +1,90 @@
+name: "CodeDebugCollab_Flow"
+description: |2-
+  Given a problem description and a correct solution strategy, alternate between a step in which code is generated, and a step in which the produced code is evaluated and useful feedback is provided. 
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+  - "public_tests_individual_io"
+  - "plan"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+
+subflows_config:
+  CodeGenerator:
+    _target_: .CF_CodeWithPlan.instantiate_from_default_config
+    name: "CodeGenerator"
+    model_name: "gpt-4"
+    human_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+        {{testing_results_summary}}
+      
+        {{code_feedback}}
+
+
+        Consider the problem statement, the last proposed solution, its issue and the provided feedback. Return a corrected version of the code that solves the original problem and resolves the issue, without any explanation, in the following format:
+        ```python
+        {{code_placeholder}}
+        ```
+      input_variables:
+        - code_feedback
+        - testing_results_summary
+      partial_variables:
+        code_placeholder: "{{python_code}}"
+    input_interface_initialized:
+      - "code_feedback"
+      - "testing_results_summary"
+  CodeDebugCritic:
+    _target_: .CF_CodeDebugCriticWithPlan.instantiate_from_default_config
+
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+      keys_to_select:
+        - "code"
+
+    reset: false
+
+  # ~~~ Code Critic Grounded in Tests ~~~
+  - goal: ""
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeDebugCritic
+
+    reset: true

CF_CodeDebugCriticWithPlan.py

@@ -0,0 +1,13 @@
+from flows.base_flows import SequentialFlow
+
+
+class CF_CodeDebugCriticWithPlan(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _early_exit(self):
+        if self.flow_state.get("all_tests_passed", False):
+            self.flow_state["code_feedback"] = None
+            return True
+
+        return super()._early_exit()

CF_CodeDebugCriticWithPlan.yaml

@@ -0,0 +1,131 @@
+name: "CodeDebugCritic_Flow"
+description: |-2
+  Given a problem description, a correct solution strategy, and a candidate solution, test the code and provide useful feedback concerning the correctness of the solution and the potential mistakes.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+  - "public_tests_individual_io"
+  - "code"
+  - "plan"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "testing_results_summary"
+  - "all_tests_passed"
+  - "code_feedback"
+
+# ~~~ Flow specification ~~~
+subflows_config:
+  CodeTestingCritic:
+    _target_: .CF_CodeTesting.instantiate_from_default_config
+  CodeCriticWrongAttempt:
+    _target_: .CF_CodeCriticWrongAttemptWithPlan.instantiate_from_default_config
+
+topology:
+  # ~~~ Code Testing Critic ~~~
+  - goal: "Test the code on the public tests and provide a results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeTestingCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: .src.data_transformations.CorrectnessFlag
+          input_key: "public_tests_results"
+          output_key: "all_tests_passed"
+        - _target_: .src.data_transformations.TestingResultsSummaryGeneration
+          output_key: "testing_results_summary"
+
+          single_test_error_message: True
+
+          no_error_template: |2-
+            ${.issue_title}
+            All of the executed tests passed.
+
+          compilation_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a compilation error.
+            ## Compilation error message:
+            {{error_message}}
+          timeout_error_template: |2-
+            ${.issue_title}
+            The execution timed out, the solution is not efficient enough.
+          runtime_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a runtime error on the following test.
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Runtime error message
+            {{error_message}}
+          single_test_error_template: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails the following test:
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ## [Failed test] Generated output
+            ```
+            {{generated_output}}
+            ```
+          all_tests_header: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails on the following tests.
+          test_error_template: |2-
+            ## [Failed test {{idx}}]
+            ### [Failed test {{idx}}] Input
+            ```
+            {{test_input}}
+            ```
+            ### [Failed test {{idx}}] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ### [Failed test {{idx}}] Generated output
+            ```
+            {{generated_output}}
+            ```
+          tests_separator: "\n\n"
+
+          issue_title: "# Issue with the last proposed solution"
+
+  # ~~~ Feedback Generator ~~~
+  - goal: "Generate feedback grounded in the test results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeCriticWrongAttempt
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyRename
+          old_key2new_key:
+            api_output: "code_feedback"
+
+    reset: true
+

CF_CodeWithPlan.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class CF_CodeWithPlan(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_CodeWithPlan.yaml

@@ -0,0 +1,89 @@
+name: "CodeFlowWithPlan_Flow"
+description: |2- 
+  Given a problem description and a high-level solution strategy implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:  # Applied when constructing the first user message.
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+  - "plan"
+
+input_interface_initialized:  # Applied when constructing all subsequent user messages.
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to provide executable Python code that solves a competitive programming problem. The code should correctly handle all corner cases in order to pass the hidden test cases, which are used to evaluate the correctness of the solution.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - input description
+      - output description
+      - example test cases
+      - (optional) explanation of the test cases
+
+    Additionally, the user will provide you with a conceptual solution to the problem which should guide your reasoning and the code implementation.
+
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    # Input description
+    {{input_description}}
+
+    # Output description
+    {{output_description}}
+
+    {{io_examples_and_explanation}}
+
+    # Conceptual solution
+    {{plan}}
+
+
+    The input should be read from the standard input and the output should be passed to the standard output.
+    Consider the problem statement and the conceptual solution, and return Python code that solves the problem. Reply in the following format:
+    ```python
+    {{code_placeholder}}
+    ```
+  input_variables:
+    - "problem_description"
+    - "input_description"
+    - "output_description"
+    - "io_examples_and_explanation"
+    - "plan"
+  partial_variables:
+    code_placeholder: "{{python_code}}"
+  template_format: jinja2

CF_Plan.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class CF_Plan(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_Plan.yaml

@@ -0,0 +1,82 @@
+name: "Plan_Flow"
+description: |2- 
+  Given a problem description, generate a high-level solution strategy.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:  # Applied when constructing the first user message.
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+input_interface_initialized:  # Applied when constructing all subsequent user messages.
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to provide a high-level conceptual solution that, if implemented, will solve a given competitive programming problem.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - input description
+      - output description
+      - example test cases
+      - (optional) explanation of the test cases
+
+    The proposed algorithm should be computationally efficient, logically correct and handle all corner cases.
+
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    # Input description
+    {{input_description}}
+
+    # Output description
+    {{output_description}}
+
+    {{io_examples_and_explanation}}
+
+
+    Return a high-level conceptual solution that would solve the problem. Be very concise, and do not provide code.
+    Reply in the following format:
+    # Conceptual solution
+    {{plan_placeholder}}
+  input_variables:
+    - "problem_description"
+    - "input_description"
+    - "output_description"
+    - "io_examples_and_explanation"
+  partial_variables:
+    plan_placeholder: "{{conceptual_solution}}"
+  template_format: jinja2

CF_PlanCollab.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class CF_PlanCollab(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_PlanCollab.yaml

@@ -0,0 +1,94 @@
+name: "PlanCollab_Flow"
+description: |2-
+  Given a problem description, alternate between a step in which a solution strategy is generated, and a step in which the solution strategy is evaluated and useful feedback is provided.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "plan"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+early_exit_key: "end_of_interaction"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .CF_Plan.instantiate_from_default_config
+    human_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+        # Feedback on the last proposed conceptual solution
+        {{plan_feedback}}
+  
+  
+        Consider the original problem statement, the last proposed solution and the provided feedback. Does the solution need to be updated? If so, provide the corrected version of the conceptual solution in the following format:
+        # Conceptual solution
+        {{plan_placeholder}}
+        otherwise, reply:
+        "Final answer."
+      input_variables:
+        - plan_feedback
+      partial_variables:
+        plan_placeholder: "{{conceptual_solution}}"
+      template_format: jinja2
+    input_interface_initialized:
+      - "plan_feedback"
+  PlanCritic:
+    _target_: .CF_PlanCritic.instantiate_from_default_config
+
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+    reset: false
+  # ~~~ Plan Critic ~~~
+  - goal: "Provide feedback for the candidate solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        api_output: "plan_feedback"
+
+    reset: true

CF_PlanCollab_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class CF_PlanCollab_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_PlanCollab_Code.yaml

@@ -0,0 +1,67 @@
+name: "PlanCollab_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy in collaboration with at critic, and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .CF_PlanCollab.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .CF_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate a plan and reflect on it."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

CF_PlanCritic.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class CF_PlanCritic(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_PlanCritic.yaml

@@ -0,0 +1,84 @@
+name: "PlanCritic_Flow"
+description: |2-
+  Given a problem description and a solution strategy candidate, provide useful feedback concerning its correctness. 
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+  - "plan"
+
+input_interface_initialized:
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+      Your goal is to identify potential issues with a conceptual solution to a given competitive programming problem.
+
+      The user will specify the problem by providing you with:
+        - the problem statement
+        - input description
+        - output description
+        - example test cases
+        - (optional) explanation of the test cases
+        - a conceptual solution attempt
+
+      Crucially, your goal is to consider all aspects of the problem and pinpoint potential issues with the conceptual solution attempt (if any), and not to provide the conceptual solution or the code implementation yourself.
+      Some aspects to consider: Are there any logical mistakes with the proposed algorithm? Are the corner cases correctly handled?
+      The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    # Input description
+    {{input_description}}
+
+    # Output description
+    {{output_description}}
+
+    {{io_examples_and_explanation}}
+
+    # Conceptual solution attempt
+    {{plan}}
+
+
+    Consider the problem statement and the solution attempt. Are there any issues with the proposed conceptual solution or it is correct? Explain your reasoning very concisely.
+  input_variables:
+    - "problem_description"
+    - "input_description"
+    - "output_description"
+    - "io_examples_and_explanation"
+    - "plan"
+  template_format: jinja2

CF_PlanReflect.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class CF_PlanReflect(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_PlanReflect.yaml

@@ -0,0 +1,84 @@
+name: "PlanReflect_Flow"
+description: |-2
+  Given a problem description, generate a plan, reflect on it and improve it until a message suggesting that the code seems correct or a maximum number of rounds is reached.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "plan"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+early_exit_key: "end_of_interaction"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .CF_Plan.instantiate_from_default_config
+  PlanReflectCritic:
+    _target_: .FixedReply_PlanReflect.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a plan."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+      keys_to_rename:
+        plan_reflect_message: "query"
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "plan"
+        - "end_of_interaction"
+
+    ### Reset flag
+    reset: false
+
+  - goal: "Generate a message that encourages reflection."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanReflectCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        fixed_reply: "plan_reflect_message"
+
+    ### Reset flag
+    reset: true

CF_PlanReflect_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class CF_PlanReflect_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_PlanReflect_Code.yaml

@@ -0,0 +1,67 @@
+name: "Plan_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy, reflect on it, and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .CF_PlanReflect.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .CF_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate a plan and reflect on it."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

CF_Plan_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class CF_Plan_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

CF_Plan_Code.yaml

@@ -0,0 +1,77 @@
+name: "Plan_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "input_description"
+  - "output_description"
+  - "io_examples_and_explanation"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .CF_Plan.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .CF_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate a plan."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

FixedReply_PlanReflect.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.FixedReplyFlowModule import FixedReplyFlow
+
+
+class FixedReply_PlanReflect(FixedReplyFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

FixedReply_PlanReflect.yaml

@@ -0,0 +1,16 @@
+name: "PlanReflectCritic"
+description: |-2
+  A flow that prompts the user to reflect on their conceptual solution and provide a corrected version if necessary.
+
+
+input_interface: []
+output_interface:
+  - fixed_reply
+
+fixed_reply: |2-
+  Consider the problem statement and the last proposed solution. Are you sure that the solution is provided in the requested format, and crucially, solves the problem?
+  If that is not the case, provide the corrected version of the conceptual solution in the following format:
+  # Conceptual solution
+  {{conceptual_solution}}
+  otherwise, reply:
+  "Final answer."