Upload 11 files

CoderFlow.py

@@ -0,0 +1,4 @@
+from flow_modules.Tachi67.AbstractBossFlowModule import AbstractBossFlow
+
+class CoderFlow(AbstractBossFlow):
+    pass

CoderFlow.yaml

@@ -0,0 +1,134 @@
+name: CoderFlow
+description: "A flow used to tackle goals with coding in a step-by-step fashion"
+
+_target_: Tachi67.CoderFlowModule.CoderFlow.instantiate_from_default_config
+
+memory_files: ???
+
+subflows_config:
+  MemoryReading:
+    _target_: Tachi67.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    output_interface:
+      - "plan"
+      - "logs"
+      - "code_library"
+
+  Planner:
+    _target_: Tachi67.CoderFlowModule.Planner_CoderFlow.instantiate_from_default_config
+    subflows_config:
+      Controller:
+        backend:
+          api_infos: ???
+          model_name:
+            openai: gpt-4
+            azure: azure/gpt-4
+      Executor:
+        subflows_config:
+          write_plan:
+            subflows_config:
+              PlanGenerator:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+
+  CtrlExMem:
+    _target_: Tachi67.CoderFlowModule.CtrlExMem_CoderFlow.instantiate_from_default_config
+    subflows_config:
+      Controller:
+        backend:
+          api_infos: ???
+          model_name:
+            openai: gpt-4
+            azure: azure/gpt-4
+      Executor:
+        subflows_config:
+          extend_library:
+            memory_files: ???
+            subflows_config:
+              Planner:
+                subflows_config:
+                  Controller:
+                    backend:
+                      api_infos: ???
+                      model_name:
+                        openai: gpt-4
+                        azure: azure/gpt-4
+                  Executor:
+                    subflows_config:
+                      write_plan:
+                        subflows_config:
+                          PlanGenerator:
+                            backend:
+                              api_infos: ???
+                              model_name:
+                                openai: gpt-4
+                                azure: azure/gpt-4
+              CtrlExMem:
+                subflows_config:
+                  Controller:
+                    backend:
+                      api_infos: ???
+                      model_name:
+                        openai: gpt-4
+                        azure: azure/gpt-4
+                  Executor:
+                    subflows_config:
+                      write_code:
+                        subflows_config:
+                          Controller:
+                            backend:
+                              api_infos: ???
+                              model_name:
+                                openai: gpt-4
+                                azure: azure/gpt-4
+                          Executor:
+                            subflows_config:
+                              write_code:
+                                memory_files: ???
+                                subflows_config:
+                                  CodeGenerator:
+                                    backend:
+                                      api_infos: ???
+                                      model_name:
+                                        openai: gpt-4
+                                        azure: azure/gpt-4
+                              test:
+                                memory_files: ???
+                      re_plan:
+                        subflows_config:
+                          Controller:
+                            backend:
+                              api_infos: ???
+                              model_name:
+                                openai: gpt-4
+                                azure: azure/gpt-4
+                          Executor:
+                            subflows_config:
+                              write_plan:
+                                subflows_config:
+                                  PlanGenerator:
+                                    backend:
+                                      api_infos: ???
+                                      model_name:
+                                        openai: gpt-4
+                                        azure: azure/gpt-4
+          re_plan:
+            subflows_config:
+              Controller:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+              Executor:
+                subflows_config:
+                  write_plan:
+                    subflows_config:
+                      PlanGenerator:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4

Controller_CoderFlow.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, List
+from flow_modules.Tachi67.ExtendLibraryFlowModule import ControllerFlow_ExtLib
+
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Command:
+    name: str
+    description: str
+    input_args: List[str]
+
+class Controller_CoderFlow(ControllerFlow_ExtLib):
+    def __init__(
+            self,
+            commands: List[Command],
+            **kwargs):
+        super().__init__(**kwargs)
+        self.system_message_prompt_template = self.system_message_prompt_template.partial(
+            commands=self.build_commands_manual(commands),
+            plan="no plans yet",
+            plan_file_location="no location yet",
+            code_library="no code library yet",
+            code_library_location="no location yet",
+            logs="no logs yet",
+        )
+        self.hint_for_model = """
+        Make sure your response is in the following format:
+              Response Format:
+              {
+              "command": "call one of the subordinates",
+              "command_args": {
+                  "arg name": "value"
+                  }
+              }
+        """
+
+    def _get_code_library_location(self, input_data):
+        assert "memory_files" in input_data, "memory_files not passed to Coder/Controller"
+        assert "code_library" in input_data["memory_files"], "code_library not in memory files"
+        return input_data["memory_files"]["code_library"]
+
+    def _get_code_library_content(self, input_data):
+        assert "code_library" in input_data, "code_library not passed to Coder/Controller"
+        code_library_content = input_data["code_library"]
+        if len(code_library_content) == 0:
+            code_library_content = 'No plan yet'
+        return code_library_content
+
+    def _update_prompts_and_input(self, input_data: Dict[str, Any]):
+        if 'goal' in input_data:
+            input_data['goal'] += self.hint_for_model
+        if 'result' in input_data:
+            input_data['result'] += self.hint_for_model
+        plan_file_location = self._get_plan_file_location(input_data)
+        plan_content = self._get_plan_content(input_data)
+        code_library_location = self._get_code_library_location(input_data)
+        code_library_content = self._get_code_library_content(input_data)
+        logs_content = self._get_logs_content(input_data)
+        self.system_message_prompt_template = self.system_message_prompt_template.partial(
+            plan_file_location=plan_file_location,
+            plan=plan_content,
+            code_library_location=code_library_location,
+            code_library=code_library_content,
+            logs=logs_content
+        )
+

Controller_CoderFlow.yaml

@@ -0,0 +1,157 @@
+_target_: Tachi67.CoderFlowModule.ControllerCoderFlow.instantiate_from_default_config
+name: "ControllerFlow_Coder"
+description: "Proposes the next action to take towards achieving the goal, and prepares the input for the branching flow"
+enable_cache: True
+
+#######################################################
+# Input keys
+#######################################################
+
+input_interface_non_initialized: # initial input keys
+  - "goal"
+  - "memory_files"
+  - "plan"
+  - "logs"
+  - "code_library
+
+input_interface_initialized:
+  - "result"
+  - "memory_files"
+  - "plan"
+  - "logs"
+  - "code_library"
+
+#######################################################
+# Output keys
+#######################################################
+
+output_interface:
+  - 'command'
+  - 'command_args'
+
+backend:
+  api_infos: ???
+  model_name:
+    openai: gpt-4
+    azure: azure/gpt-4
+
+commands:
+  extend_library:
+    description: "Given goal, write functions to achieve the goal, and then extend the library with the functions"
+    input_args: [ "goal" ]
+  re_plan:
+    description: "When something is wrong with current plan, draft another plan based on the old plan and information about why it's bad or how to refine it."
+    input_args: [ "goal" ]
+  finish:
+    description: "Signal that the objective has been satisfied, return the summary of what was done"
+    input_args: [ "summary" ]
+  manual_finish:
+    description: "The user demands to quit and terminate the current process"
+    input_args: [ ]
+  ask_user:
+    description: "Ask user a question for confirmation or assistance"
+    input_args: [ "question" ]
+  update_plan:
+    description: "Pass the updated plan to edit plan file and override current plan"
+    input_args: [ "updated_plan" ]
+  run_code:
+    description: "Run a code script written by yourself, e.g. downloading a package to the current environment, importing and calling a function from the code library"
+    input_args: [ "code", "language" ]
+
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+          Your department is in charge of achieving goals with writing and executing code. You are the leader of this department.
+    
+          You have a code library located at {{code_library_location}}, which contains functions that are already written and saved by your subordinates. 
+          Here are the functions in the library:
+            {{code_library}}
+    
+          You work with several subordinates, they will be in charge of the specific tasks, including extending the code library, running a code script (you need to write the code script yourself, e.g. importing and calling a function from the code library), re-planning, etc.
+          
+          To call one of the subordinates, you need to call the corresponding command with necessary arguments, here are the commands and their descriptions:
+            {{commands}}
+          
+          You are given a step-by-step plan to finish the goal, **make sure you follow the plan**, **notice that, if you are informed that the plan is overriden, this plan is the new plan you should stick to.**, the plan is located in a plan file {{plan_file_location}}:
+            {{plan}}
+              
+          You should execute the plan step-by-step, for each step, you should do the following workflows:
+          0.1 Whenever the user demands to quit or terminate the current process, call `manual_finish` command.
+          0.2 Whenever in doubt, or you have something to ask, or confirm to the user, call `ask_user` with your question.
+          0.3 During the execution of the plan, if something goes wrong, call the `re_plan` with detailed information about what was wrong.
+          1. If the current step of plan asks to extend the library, call `extend_library` with the goal of the current step of plan.
+          2. In one of the following situations, call `run_code` with the code script you write:
+            2.1. The current step of plan does not require to extend the library, but requires to run a code script.
+            2.2. The current step of plan requires to import and run some functions from the library. In this case you **MUST** make sure you import the library, something like `from LIBRARY_NAME import FUNCTION_NAME` should suffice.
+            2.3. You need to download a package to the current environment, e.g. `pip install PACKAGE_NAME`, in this case the language of code should be `shell`.
+          After the code is run, the user will provide feedback about the execution, react to the feedback accordingly.
+          3. Whenever you have done one step of the plan, do the following:
+            3.1 Reflect on what plan you are having right now.
+            3.2 Reflect on which step of the plan you just finished.
+            3.3 Generate a plan, **it is exactly the same as the plan you have now, but with the current step of plan marked as done**
+            3.4 Call `update_plan` with the plan you just generated.
+          4. Proceed to the next step of the plan, go back to workflow 1 or 2.
+          5. When every step of the plan is done, call the `finish` command, with a summary of what was done.
+          
+          Here is an example of execution:  
+          ### Beginning of an example execution: ###
+          Plan: 1. Extend the library with a function that reads the stock prices from yahoo finance for the last `k` months for a company given its `company_code`  2. Call this function for `company_code`=TSLA and `k`=6.
+          You start from step 1 of the plan, execute workflow 1, the extend_library command is called with the goal of step 1 of the plan.
+          You are informed of what functions are written and saved to the library.
+          You realize that step 1 is done, you go to workflow 3 to update the plan:
+              3.1 You recall the plan you have.
+              3.2 You realize step 1 of the plan is done.
+              3.3 You generate the updated plan: 1. Extend the library with a function that reads the stock prices for the last k months for a company given its `company_code` (DONE) 2. Call this function for `company_code`=TSLA and k=6.
+              3.4 You call `update_plan` with the generated plan.
+          The updated plan will override the existing plan, you are informed of the behaviour of override.
+          You enter step 2 of the plan. 
+          You go to workflow 2 to run a code script, you write a code script that imports the function you just wrote and call it with the arguments specified in the plan.
+          You are informed that package yahoo finance is not installed, the user instructs to install the yahoo finance package, you go to workflow 2 to run a code script, you write a code script that installs the package.
+          You are informed that the package is installed, you go to workflow 2 to run a code script, you write a code script that imports the function you just wrote and call it with the arguments specified in the plan.
+          You are informed that the code has been successfully ran, the user is satisfied with the result.
+          You realize that step 2 is done, you go to workflow 3 to update the plan:
+              3.1 You recall the plan you have.
+              3.2 You realize step 2 of the plan is done.
+              3.3 You generate the updated plan: 1. Extend the library with a function that reads the stock prices for the last k months for a company given its `company_code` (DONE) 2. Call this function for `company_code`=TSLA and k=6. (DONE)
+              3.4 You call `update_plan` with the generated plan.
+          The updated plan will override the existing plan, you are informed of the behaviour of override.
+          All steps are done, you call `finish`, with a summary of what functions are written and saved to the library.
+          ### End of an example of execution ###
+    
+          Here is a list of history actions you have taken, for your reference:
+            {{logs}}
+    
+          Constraints:
+          1. Exclusively use the commands listed in double quotes e.g. "command name"
+          
+          Your response **MUST** be in the following format:
+              Response Format:
+              {
+              "command": "call one of the subordinates",
+              "command_args": {
+                  "arg name": "value"
+                  }
+              }
+          Ensure your responses can be parsed by Python json.loads
+
+  input_variables: ["commands", "plan_file_location", "plan", "logs", "code_library_location", "code_library"]
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the result of your previous action:
+    {{result}}
+  input_variables:
+    - "result"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the goal you need to achieve, follow your plan to finish the goal:
+    {{goal}}
+  input_variables:
+    - "goal"
+  template_format: jinja2

CtrlExMem_CoderFlow.py

@@ -0,0 +1,46 @@
+from typing import Dict, Any
+
+from flow_modules.Tachi67.AbstractBossFlowModule import CtrlExMemFlow
+from flows.base_flows import CircularFlow
+
+class CtrlExMem_CoderFlow(CtrlExMemFlow):
+    def _on_reach_max_round(self):
+        self._state_update_dict({
+            "answer": "the maximum amount of rounds was reached before the coder flow has done the job",
+            "summary": "CoderFlow: the maximum amount of rounds was reached before the flow has done the job",
+            "status": "unfinished"
+        })
+
+    @CircularFlow.output_msg_payload_processor
+    def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        command = output_payload["command"]
+        if command == "finish":
+            return {
+                "EARLY_EXIT": True,
+                "answer": output_payload["command_args"]["summary"],
+                "summary": "Coder: " + output_payload["command_args"]["summary"],
+                "status": "finished"
+            }
+        elif command == "manual_finish":
+            # ~~~ return the manual quit status ~~~
+            return {
+                "EARLY_EXIT": True,
+                "answer": "CoderFlow was terminated explicitly by the user, process is unfinished",
+                "summary": "Coder: process terminated by the user explicitly, nothing generated",
+                "status": "unfinished"
+            }
+        elif command == "update_plan":
+            keys_to_fetch_from_state = ["memory_files"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            output_payload["command_args"]["memory_files"] = fetched_state["memory_files"]
+            return output_payload
+
+        elif command == "re_plan":
+            keys_to_fetch_from_state = ["plan", "memory_files"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            output_payload["command_args"]["plan_file_location"] = fetched_state["memory_files"]["plan"]
+            output_payload["command_args"]["plan"] = fetched_state["plan"]
+            return output_payload
+
+        else:
+            return output_payload

CtrlExMem_CoderFlow.yaml

@@ -0,0 +1,168 @@
+_target_: Tachi67.CoderFlowModule.CtrlExMem_CoderFlow.instantiate_from_default_config
+name: "CtrlExMem_CoderFlow"
+description: "MemorizedControllerExecutor flow for Coder flow"
+
+input_interface:
+  - "plan"
+  - "logs"
+  - "code_library"
+  - "memory_files"
+  - "goal"
+
+subflows_config:
+  Controller:
+    _target_: Tachi67.CoderFlowModule.Controller_CoderFlow.instantiate_from_default_config
+    backend:
+      api_infos: ???
+      model_name:
+        openai: gpt-4
+        azure: azure/gpt-4
+  Executor:
+    _target_: flows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      extend_library:
+        _target_: Tachi67.ExtendLibraryFlowModule.ExtendLibraryFlow.instantiate_from_default_config
+        memory_files: ???
+        subflows_config:
+          Planner:
+            _target_: Tachi67.PlanWriterFlowModule.PlanWriterFlow.instantiate_from_default_config
+            subflows_config:
+              Controller:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+              Executor:
+                subflows_config:
+                  write_plan:
+                    subflows_config:
+                      PlanGenerator:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4
+          CtrlExMem:
+            _target_: Tachi67.ExtendLibraryFlowModule.CtrlExMem_ExtLib.instantiate_from_default_config
+            subflows_config:
+              Controller:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+              Executor:
+                subflows_config:
+                  write_code:
+                    subflows_config:
+                      Controller:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4
+                      Executor:
+                        subflows_config:
+                          write_code:
+                            memory_files: ???
+                            subflows_config:
+                              CodeGenerator:
+                                backend:
+                                  api_infos: ???
+                                  model_name:
+                                    openai: gpt-4
+                                    azure: azure/gpt-4
+                          test:
+                            memory_files: ???
+                  re_plan:
+                    subflows_config:
+                      Controller:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4
+                      Executor:
+                        subflows_config:
+                          write_plan:
+                            subflows_config:
+                              PlanGenerator:
+                                backend:
+                                  api_infos: ???
+                                  model_name:
+                                    openai: gpt-4
+                                    azure: azure/gpt-4
+      ask_user:
+        _target_: Tachi67.ExtendLibraryFlowModule.ExtLibAskUserFlow.instantiate_from_default_config
+      re_plan:
+        _target_: Tachi67.ReplanningFlowModule.ReplanningFlow.instantiate_from_default_config
+        subflows_config:
+          Controller:
+            backend:
+              api_infos: ???
+              model_name:
+                openai: gpt-4
+                azure: azure/gpt-4
+          Executor:
+            subflows_config:
+              write_plan:
+                subflows_config:
+                  PlanGenerator:
+                    backend:
+                      api_infos: ???
+                      model_name:
+                        openai: gpt-4
+                        azure: azure/gpt-4
+      run_code:
+        _target_: Tachi67.RunCodeFlowModule.RunCodeFlow.instantiate_from_default_config
+      update_plan:
+        _target_: Tachi67.CoderFlowModule.UpdatePlanAtomicFlow.yaml.instantiate_from_default_config
+  MemoryReading:
+    _target_: Tachi67.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    output_interface:
+      - "plan"
+      - "logs"
+      - "code_library"
+
+topology:
+  - goal: "Select the next action and prepare the input for the executor."
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface:
+      _target_: CtrlExMem_CoderFlow.detect_finish_or_continue
+    reset: false
+
+  - goal: "Execute the action specified by the Controller."
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data: observation
+      keys_to_unpack: ["observation"]
+    reset: false
+
+  - goal: "Write memory to memory files"
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: MemoryWriting
+    reset: false
+
+  - goal: "Read memory from memory files (flow_state)"
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: MemoryReading
+    reset: false

Planner_CoderFlow.py

@@ -0,0 +1,63 @@
+from typing import Dict, Any
+import os
+from flow_modules.Tachi67.PlanWriterFlowModule import PlanWriterFlow
+from flows.base_flows import CircularFlow
+
+
+
+class Planner_CoderFlow(PlanWriterFlow):
+    def _on_reach_max_round(self):
+        self._state_update_dict({
+            "plan": "The maximum amount of rounds was reached before the model generated the plan.",
+            "status": "unfinished"
+        })
+
+    @CircularFlow.output_msg_payload_processor
+    def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        command = output_payload["command"]
+        if command == "finish":
+            # ~~~ fetch temp file location, plan content, memory file (of upper level flow e.g. ExtLib) from flow state
+            keys_to_fetch_from_state = ["temp_plan_file_location", "plan", "memory_files"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            temp_plan_file_location = fetched_state["temp_plan_file_location"]
+            plan_content = fetched_state["plan"]
+            plan_file_location = fetched_state["memory_files"]["plan"]
+
+            # ~~~ delete the temp plan file ~~~
+            if os.path.exists(temp_plan_file_location):
+                os.remove(temp_plan_file_location)
+
+            # ~~~ write plan content to plan file ~~~
+            with open(plan_file_location, 'w') as file:
+                file.write(plan_content)
+
+            # ~~~ return the plan content ~~~
+            return {
+                "EARLY_EXIT": True,
+                "plan": plan_content,
+                "summary": "Coder/PlanWriter: " + output_payload["command_args"]["summary"],
+                "status": "finished"
+            }
+        elif command == "manual_finish":
+            # ~~~ delete the temp plan file ~~~
+            keys_to_fetch_from_state = ["temp_plan_file_location"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            temp_plan_file_location = fetched_state["temp_plan_file_location"]
+            if os.path.exists(temp_plan_file_location):
+                os.remove(temp_plan_file_location)
+            # ~~~ return the manual quit status ~~~
+            return {
+                "EARLY_EXIT": True,
+                "plan": "no plan was generated",
+                "summary": "Coder/PlanWriter: PlanWriter was terminated explicitly by the user, process is unfinished",
+                "status": "unfinished"
+            }
+        elif command == "write_plan":
+            keys_to_fetch_from_state = ["memory_files", "code_library"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            output_payload["command_args"]["plan_file_location"] = fetched_state["memory_files"]["plan"]
+            output_payload["command_args"]["code_library_location"] = fetched_state["memory_files"]["code_library"]
+            output_payload["command_args"]["code_library"] = fetched_state["code_library"]
+            return output_payload
+        else:
+            return output_payload

Planner_CoderFlow.yaml

@@ -0,0 +1,135 @@
+name: "Planner/Coder"
+description: "Generates plan with interactions with the user, used for the coder class"
+
+_target_: Tachi67.CoderFlowModule.Planner_CoderFlow.instantiate_from_default_config
+
+input_interface:
+  - "goal"
+  - "code_library"
+  - "memory_files"
+
+output_interface:
+  - "plan"
+  - "status"
+  - "summary"
+
+### Subflows specification
+subflows_config:
+  Controller:
+    _target_: Tachi67.PlanWriterFlowModule.PlanWriterCtrlFlow.instantiate_from_default_config
+    backend:
+      api_infos: ???
+      model_name:
+        openai: gpt-4
+        azure: azure/gpt-4
+
+  Executor:
+    _target_: flows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      write_plan:
+        _target_: Tachi67.InteractivePlanGenFlowModule.InteractivePlanGenFlow.instantiate_from_default_config
+        input_interface:
+          - "goal"
+          - "plan_file_location"
+          - "code_library_location"
+          - "code_library"
+        subflows_config:
+          PlanGenerator:
+            _target_: Tachi67.PlanGeneratorFlowModule.PlanGeneratorAtomicFlow.instantiate_from_default_config
+            backend:
+              api_infos: ???
+              model_name:
+                openai: gpt-4
+                azure: azure/gpt-4
+            input_interface_non_initialized:
+              - "goal"
+              - "code_library"
+              - "code_library_location"
+            input_interface_initialized:
+              - "goal"
+              - "code_library"
+              - "code_library_location"
+            system_message_prompt_template:
+              _target_: flows.prompt_template.JinjaPrompt
+              template: |2-
+                You are a planner for a coding department, you write step-by-step plans for the coders to follow and execute.
+
+                You and the coders work with a code library located at {{code_library_location}}, **it is important that when you make plans, make the best use of the functions in the library.** Here are the contents in the library:
+                {{code_library}}
+
+                The coders are able to read and write the code library, namely, they can import and use the functions in the library, and they are also able to extend the library.
+
+                Apart from reading and writing code, the coders are also able to execute a code script written by themselves.
+
+                **You task is: given a goal to achieve, write step-by-step plans for the coders, each step of your plan should involve one of the three actions:
+                  1. Extend the code library with a function, describe the purpose, input and output of this function so that the coders understand what you mean and write appropriate functions.
+                  2. Run a code script, for example, downloading a package after you realize the current environment lacks it; import and call one function from the code library with specific inputs.
+                  3. Give a final answer**
+
+                Here are some criteria you should consider in order to write a good plan:
+                  1. The plan should be nicely separated into steps, each step should involve extending the library, or running code, or giving a final answer.
+                  2. Always try to use the functions already existent in the code library. To use them, instruct the coders to import and run the function from the code library.
+                  3. If the current milestone cannot be solved by the functions in the library, generalize the problem and instruct the coders to extend the library with a function to deal with this problem.
+                    For example, suppose the goal you need to achieve is "Download Google's stock prices from the last 6 months from Yahoo finance", there is no function available to solve this in the library. 
+                    In this case, your step of plan is: "Extend the library with a function that reads the stock prices for the last k months for a company given its `company_code`"
+                  4. On top of criterion 3, when you instruct the coders to extend the library, make sure that:
+                    4.1. Each time you instruct to extend the library, ask for only one function.
+                    4.2. If the problem you generalize involves several separated steps and should not be done in one function, decompose the problem into several sub-problems and instruct the coders to extend the library with a function for each sub-problem, this should be done in several steps of plan.
+
+                Performance Evaluation:
+                  1. Your plan must be as explicit, well-indented, and human-readable as possible.
+                  2. Your plan must be step-by-step with number indexes, each step involves extending the library, or running code, or answering.
+                  3. You should make plans with as few steps as possible.
+
+                **It's important that you should only respond in JSON format as described below:**
+                Response Format:
+                {
+                "plan": "A step-by-step plan to finish the given goal",
+                }
+                Ensure your responses can be parsed by Python json.loads
+              input_variables:
+                - "code_library_location"
+                - "code_library"
+
+          PlanFileEditor:
+            _target_: Tachi67.PlanFileEditFlowModule.PlanFileEditAtomicFlow.instantiate_from_default_config
+
+          ParseFeedback:
+            _target_: Tachi67.ParseFeedbackFlowModule.ParseFeedbackAtomicFlow.instantiate_from_default_config
+            input_interface:
+              - "temp_plan_file_location"
+            output_interface:
+              - "plan"
+              - "feedback"
+
+      ask_user:
+        _target_: Tachi67.PlanWriterFlowModule.PlanWriterAskUserFlow.instantiate_from_default_config
+
+
+early_exit_key: "EARLY_EXIT"
+
+topology:
+  - goal: "Select the next action and prepare the input for the executor."
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface:
+      _target_: Planner_CoderFlow.detect_finish_or_continue
+    reset: false
+
+  - goal: "Execute the action specified by the Controller."
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data: observation
+      keys_to_unpack: ["observation"]
+    reset: false

UpdatePlanAtomicFlow.py

@@ -0,0 +1,30 @@
+#TODO: generalize updateplanatomicflow with the one in extendlibrary
+from typing import Dict, Any
+from flows.base_flows.atomic import AtomicFlow
+class UpdatePlanAtomicFlow(AtomicFlow):
+    def _check_input(self, input_data: Dict[str, Any]):
+        assert "memory_files" in input_data, "memory_files not passed to UpdatePlanAtomicFlow.yaml"
+        assert "plan" in input_data["memory_files"], "plan not in memory_files"
+
+    def _call(self, input_data: Dict[str, Any]):
+        try:
+            plan_file_location = input_data["memory_files"]["plan"]
+            plan_to_write = input_data["updated_plan"]
+            with open(plan_file_location, 'w') as file:
+                file.write(plan_to_write + "\n")
+            return {
+                "result": "updated plan saved to the plan file and has overriden the previous plan",
+                "summary": f"Coder/UpdatePlanFlow: updated plan saved to {plan_file_location}"
+            }
+        except Exception as e:
+            return {
+                "result": f"Error occurred: {str(e)}",
+                "summary": f"Coder/UpdatePlanFlow: error occurred while writing updated plan: {str(e)}"
+            }
+
+    def run(
+            self,
+            input_data: Dict[str, Any]
+    ):
+        self._check_input(input_data)
+        return self._call(input_data)

UpdatePlanAtomicFlow.yaml

@@ -0,0 +1,9 @@
+_target_: Tachi67.CoderFlowModule.UpdatePlanAtomicFlow.instantiate_from_default_config
+name: "UpdatePlanAtomicFlow"
+description: "Writes new plan to plan file"
+
+input_interface:
+  - "updated_plan"
+
+output_interface:
+  - "result"

__init__.py

@@ -0,0 +1,19 @@
+dependencies = [
+    {"url": "Tachi67/AbstractBossFlowModule", "revision": "main"},
+    {"url": "Tachi67/MemoryReadingFlowModule", "revision": "main"},
+    {"url": "Tachi67/PlanWriterFlowModule", "revision": "main"},
+    {"url": "Tachi67/ExtendLibraryFlowModule", "revision": "main"},
+    {"url": "Tachi67/RunCodeFlowModule", "revision": "main"},
+    {"url": "Tachi67/ReplanningFlowModule", "revision": "main"},
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "5683a922372c5fa90be9f6447d6662d8d80341fc"},
+    {"url": "aiflows/ChatFlowModule", "revision": "a749ad10ed39776ba6721c37d0dc22af49ca0f17"},
+]
+
+from flows import flow_verse
+flow_verse.sync_dependencies(dependencies)
+
+from .UpdatePlanAtomicFlow import UpdatePlanAtomicFlow
+from .CoderFlow import CoderFlow
+from .Controller_CoderFlow import Controller_CoderFlow
+from .CtrlExMem_CoderFlow import CtrlExMem_CoderFlow
+from .Planner_CoderFlow import Planner_CoderFlow