Upload 16 files

ControllerFlow_ExtLib.py

@@ -0,0 +1,128 @@
+import json
+from copy import deepcopy
+from typing import Any, Dict, List
+
+from flow_modules.aiflows.ChatFlowModule import ChatAtomicFlow
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Command:
+    name: str
+    description: str
+    input_args: List[str]
+
+class ControllerFlow_ExtLib(ChatAtomicFlow):
+    """Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py"""
+    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_file_location="no location yet",
+            plan="no plan 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 commands you have e.g. `write_code`",
+              "command_args": {
+                  "arg name": "value"
+                  }
+              }
+        """
+
+    @staticmethod
+    def _build_commands_manual(commands: List[Command]) -> str:
+        ret = ""
+        for i, command in enumerate(commands):
+            command_input_json_schema = json.dumps(
+                {input_arg: f"YOUR_{input_arg.upper()}" for input_arg in command.input_args})
+            ret += f"{i + 1}. {command.name}: {command.description} Input arguments (given in the JSON schema): {command_input_json_schema}\n"
+        return ret
+
+    def _get_plan_file_location(self, input_data: Dict[str, Any]):
+        assert "memory_files" in input_data, "memory_files not passed to Extlib/Controller"
+        assert "plan" in input_data["memory_files"], "plan not in memory files"
+        return input_data["memory_files"]["plan"]
+
+    def _get_plan_content(self, input_data: Dict[str, Any]):
+        assert "plan" in input_data, "plan not passed to Extlib/Controller"
+        plan_content = input_data["plan"]
+        if len(plan_content) == 0:
+            plan_content = 'No plan yet'
+        return plan_content
+
+    def _get_logs_content(self, input_data: Dict[str, Any]):
+        assert "logs" in input_data, "logs not passed to Extlib/Controller"
+        logs_content = input_data["logs"]
+        if len(logs_content) == 0:
+            logs_content = "No logs yet"
+        return logs_content
+
+    @classmethod
+    def instantiate_from_config(cls, config):
+        flow_config = deepcopy(config)
+
+        kwargs = {"flow_config": flow_config}
+
+        # ~~~ Set up prompts ~~~
+        kwargs.update(cls._set_up_prompts(flow_config))
+
+        # ~~~Set up backend ~~~
+        kwargs.update(cls._set_up_backend(flow_config))
+
+        # ~~~ Set up commands ~~~
+        commands = flow_config["commands"]
+        commands = [
+            Command(name, command_conf["description"], command_conf["input_args"]) for name, command_conf in
+            commands.items()
+        ]
+        kwargs.update({"commands": commands})
+
+        # ~~~ Instantiate flow ~~~
+        return cls(**kwargs)
+
+    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)
+        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,
+            logs=logs_content
+        )
+
+    def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        self._update_prompts_and_input(input_data)
+
+        # ~~~when conversation is initialized, append the updated system prompts to the chat history ~~~
+        if self._is_conversation_initialized():
+            updated_system_message_content = self._get_message(self.system_message_prompt_template, input_data)
+            self._state_update_add_chat_message(content=updated_system_message_content,
+                                                role=self.flow_config["system_name"])
+            
+        while True:
+            api_output = super().run(input_data)["api_output"].strip()
+            try:
+                start = api_output.index("{")
+                end = api_output.rindex("}") + 1
+                json_str = api_output[start:end]
+                return json.loads(json_str)
+            except (json.decoder.JSONDecodeError, json.JSONDecodeError):
+                updated_system_message_content = self._get_message(self.system_message_prompt_template, input_data)
+                self._state_update_add_chat_message(content=updated_system_message_content,
+                                                    role=self.flow_config["system_name"])
+                new_goal = "The previous respond cannot be parsed with json.loads. Next time, do not provide any comments or code blocks. Make sure your next response is purely json parsable."
+                new_input_data = input_data.copy()
+                new_input_data['result'] = new_goal
+                input_data = new_input_data

ControllerFlow_ExtLib.yaml

@@ -0,0 +1,149 @@
+_target_: flow_modules.aiflows.ExtendLibraryFlowModule.ControllerFlow_ExtLib.instantiate_from_default_config
+name: "ControllerFlow_ExtendLibrary"
+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"
+
+input_interface_initialized:
+  - "goal"
+  - "result"
+  - "memory_files"
+  - "plan"
+  - "logs"
+
+#######################################################
+# Output keys
+#######################################################
+
+output_interface:
+  - 'command'
+  - 'command_args'
+
+backend:
+  api_infos: ???
+  model_name:
+    openai: gpt-4
+    azure: azure/gpt-4
+
+commands:
+  write_code:
+    description: "Write code to finish the current step of plan with user interaction"
+    input_args: ["goal"]
+  save_code:
+    description: "When code is written by the coder, save the code to the library"
+    input_args: []
+  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"]
+
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+          Your department is in charge of writing code and extending the code library with the code written. You are the leader of this department.
+    
+          Here is the goal you need to achieve, follow your plan to finish the goal:
+          {{goal}}
+          
+          You work with several subordinates, they will be in charge of the specific tasks, including writing code, saving code to the library, etc.
+          
+          You are given a step-by-step plan to finish the goal, **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}}
+          
+          Your **ONLY** task is to take the user's goal for you, to decide which command to call.
+                             
+          You **must not** write code nor write plan yourself. You only decide whether to call the coder with specified goals or to finish.
+    
+          Each step of the plan should involve writing one function, **for each step in the plan, your workflow**:
+          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. Based on the current step of plan, call `write_code` with the current goal in the step of plan, the code writer will write some code.
+          2. After code is written, call `save_code` to save the code to the code library, **you do not need to worry about the details of the code nor the library, they will be handled by your subordinates.**
+          3. **When workflow 1 and workflow 2 are successfully executed, that means the current step of plan is done.** 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.
+          5. When every step of the plan is done, call the `finish` command, with a summary of what functions are written and saved.
+
+          **You MUST call `update_plan` whenever you realize one step of the plan is done.**
+            
+          ### Beginning of an example execution: ###
+          Plan: 1. Write a function that fetches weather data from google; 2. Write a function that prints the weather data in a formatted way.
+          You start from step 1 of the plan, execute workflow 1, code is written.
+          You are informed that code is written, you go to workflow 2 to save the code.
+          You are informed that the code is saved, 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. Write a function that fetches weather data from google;(DONE) 2. Write a function that prints the weather data in a formatted way.
+              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 go on with the next step of the plan, do the same as above.
+          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 code writer, the tester, or to finish",
+              "command_args": {
+                  "arg name": "args value"
+                  }
+              }
+          Ensure your responses can be parsed by Python json.loads
+          
+  
+          Available Functions:
+          {{commands}}
+  input_variables: ["commands", "plan_file_location", "plan", "logs", "goal"]
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: aiflows.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_: aiflows.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
+
+previous_messages:
+  last_k: 3

CtrlExMem_ExtLib.py

@@ -0,0 +1,64 @@
+from typing import Dict, Any
+
+from flow_modules.aiflows.AbstractBossFlowModule import CtrlExMemFlow
+from aiflows.base_flows import CircularFlow
+
+class CtrlExMem_ExtLib(CtrlExMemFlow):
+    """This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
+    See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+    *Input Interface*:
+    - `plan`
+    - `logs`
+    - `memory_files`
+    - `goal`
+    *Output Interface*
+    - `result` (str): The result of the flow, the result will be returned to the caller.
+    - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow.
+    """
+    def _on_reach_max_round(self):
+        self._state_update_dict({
+            "result": "the maximum amount of rounds was reached before the extend library flow has done the job",
+            "summary": "ExtendLibraryFlow: 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,
+                "result": output_payload["command_args"]["summary"],
+                "summary": "ExtendLibrary: " + output_payload["command_args"]["summary"],
+                "status": "finished"
+            }
+        elif command == "manual_finish":
+            # ~~~ return the manual quit status ~~~
+            return {
+                "EARLY_EXIT": True,
+                "result": "ExtendLibraryFlow was terminated explicitly by the user, process is unfinished",
+                "summary": "ExtendLibrary: process terminated by the user explicitly, nothing generated",
+                "status": "unfinished"
+            }
+        elif command == "save_code":
+            keys_to_fetch_from_state = ["code", "memory_files"]
+            fetched_state = self._fetch_state_attributes_by_keys(keys=keys_to_fetch_from_state)
+            output_payload["command_args"]["code"] = fetched_state["code"]
+            output_payload["command_args"]["memory_files"] = fetched_state["memory_files"]
+            return output_payload
+
+        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_ExtLib.yaml

@@ -0,0 +1,106 @@
+_target_: flow_modules.aiflows.ExtendLibraryFlowModule.CtrlExMem_ExtLib.instantiate_from_default_config
+name: "CtrlExMem_ExtLibFlow"
+description: "MemorizedControllerExecutor flow for ExtendLibrary flow"
+
+subflows_config:
+  Controller:
+    _target_: flow_modules.aiflows.ExtendLibraryFlowModule.ControllerFlow_ExtLib.instantiate_from_default_config
+    backend:
+      api_infos: ???
+      model_name:
+        openai: gpt-4
+        azure: azure/gpt-4
+  Executor:
+    _target_: aiflows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      write_code:
+        _target_: flow_modules.aiflows.CodeWriterFlowModule.CodeWriterFlow.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:
+                  CodeGenerator:
+                    backend:
+                      api_infos: ???
+                      model_name:
+                        openai: gpt-4
+                        azure: azure/gpt-4
+      save_code:
+        _target_: flow_modules.aiflows.ExtendLibraryFlowModule.SaveCodeAtomicFlow.instantiate_from_default_config
+      ask_user:
+        _target_: flow_modules.aiflows.ExtendLibraryFlowModule.ExtLibAskUserFlow.instantiate_from_default_config
+      re_plan:
+        _target_: flow_modules.aiflows.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
+
+      update_plan:
+        _target_: flow_modules.aiflows.ExtendLibraryFlowModule.UpdatePlanAtomicFlow.instantiate_from_default_config
+
+topology:
+  - goal: "Select the next action and prepare the input for the executor."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface:
+      _target_: CtrlExMem_ExtLib.detect_finish_or_continue
+    reset: false
+
+  - goal: "Execute the action specified by the Controller."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data.code: code
+        branch_output_data.plan: plan
+        branch_output_data.status: status
+        branch_output_data.summary: summary
+        branch_output_data.result: result
+      keys_to_delete: ["branch_output_data"]
+    reset: false
+
+  - goal: "Write memory to memory files"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: MemoryWriting
+    reset: false
+
+  - goal: "Read memory from memory files (flow_state)"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: MemoryReading
+    reset: false

ExtLibAskUserFlow.py

@@ -0,0 +1,44 @@
+from flow_modules.aiflows.HumanStandardInputFlowModule import HumanStandardInputFlow
+
+from typing import Dict, Any
+
+from aiflows.messages import UpdateMessage_Generic
+
+from aiflows.utils import logging
+
+log = logging.get_logger(f"aiflows.{__name__}")
+
+# TODO: extract this flow to a seperate flow module for modularity.
+class ExtLibAskUserFlow(HumanStandardInputFlow):
+    """This class is used to ask for user feedback whenever the controller is unsure of something, or need confirmation, etc.
+
+    *Expected Input*:
+    - `question`: The question asked by the controller
+
+    *Expected Behaviour*:
+    - The question is displayed, and the user gives feedback by inputing string.
+
+    *Expected Ouput*:
+    - `result`: The input of the user.
+    - `summary`: The summary that will be written by the caller.
+    """
+    def run(self,
+            input_data: Dict[str, Any]) -> Dict[str, Any]:
+
+        query_message = self._get_message(self.query_message_prompt_template, input_data)
+        state_update_message = UpdateMessage_Generic(
+            created_by=self.flow_config['name'],
+            updated_flow=self.flow_config["name"],
+            data={"query_message": query_message},
+        )
+        self._log_message(state_update_message)
+
+        log.info(query_message)
+        human_input = self._read_input()
+
+        question = input_data["question"]
+        response = {}
+        response["result"] = human_input
+        response["summary"] = f"Question raised: {question}; answer of user: {human_input}"
+
+        return response

ExtLibAskUserFlow.yaml

@@ -0,0 +1,9 @@
+_target_: aiflows.ExtendLibraryFlowModule.ExtLibAskUserFlow.instantiate_from_default_config
+request_multi_line_input_flag: False
+end_of_input_string: EOI
+
+query_message_prompt_template:
+  template: |2-
+    {{question}}
+  input_variables:
+    - "question"

ExtendLibraryFlow.py

@@ -0,0 +1,43 @@
+from typing import Dict, Any
+from aiflows.utils import logging
+log = logging.get_logger(__name__)
+
+from flow_modules.aiflows.AbstractBossFlowModule import AbstractBossFlow
+class ExtendLibraryFlow(AbstractBossFlow):
+    """ExtendLibraryFlow is one branch executor of CoderFlow. At a higher level, it takes the goal
+    from the Coder, writes functions in an interactive way, test the code and append the newly written function to
+    the code library.
+
+    Workflow of ExtendLibrary:
+    0. Coder calls ExtendLibrary with a goal.
+    1. MemoryReading reads logs, plan, and code library.
+    2. Planner makes a plan based on the goal.
+    3. Write code in an interactive fashion.
+    4. Test code.
+    5. Finish, writes code to the library.
+    Step 3-5 is done via prompting the controller.
+
+    *Input Interface (expected input)*
+    - `goal` (str): The goal from the caller (source flow, i.e. CoderFlow)
+    *Output Interface (expected output)*
+    - `result` (str): The result of the flow, the result will be returned to the caller (i.e. CoderFlow).
+    - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow (i.e. CoderFlow).
+    """
+    def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        # ~~~ sets the input_data in the flow_state dict ~~~
+        self._state_update_dict(update_data=input_data)
+
+        # ~~~ set the memory file to the flow state ~~~
+        self._state_update_dict(update_data={"memory_files": self.memory_files})
+
+        max_rounds = self.flow_config.get("max_rounds", 1)
+        if max_rounds is None:
+            log.info(f"Running {self.flow_config['name']} without `max_rounds` until the early exit condition is met.")
+
+        self._sequential_run(max_rounds=max_rounds)
+
+        output = self._get_output_from_state()
+
+        self.reset(full_reset=True, recursive=True, src_flow=self)
+
+        return output

ExtendLibraryFlow.yaml

@@ -0,0 +1,91 @@
+name: ExtendLibraryFlow
+description: "A flow used to extend the content in the code library"
+
+_target_: flow_modules.aiflows.ExtendLibraryFlowModule.ExtendLibraryFlow.instantiate_from_default_config
+
+memory_files: ???
+
+subflows_config:
+  MemoryReading:
+    _target_: flow_modules.aiflows.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    output_interface:
+      - "plan"
+      - "logs"
+      - "code_library"
+
+  Planner:
+    _target_: flow_modules.aiflows.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_: flow_modules.aiflows.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
+      MemoryReading:
+       _target_: flow_modules.aiflows.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+       output_interface:
+         - "plan"
+         - "logs"
+         - "code_library"

README.md

@@ -1,3 +1,264 @@
----
-license: mit
----
+### Structure of ExtendLibraryFlow
+
+```
+     goal, memory_files (dict)
+             |
+             v
+    +-------------------+
+    |  MemoryReading    |  Reads in the content of the memory files
+    |    Flow           |
+    +-------------------+
+             |
+             | (memory_content)
+             |
+             v
+    +-------------------+
+    |    PlanWriter     |  Writes a step-by-step plan to achieve the goal
+    +-------------------+
+             |
+             | (plan)
+             |
+             v
+    +-------------------+
+    |   CtrlExMemFlow   |  Illustrated below. Carries out the plan in an controller-executor fashion,
+    |                   |  with memory management mechanisms.
+    +-------------------+
+             |
+    (summary, result)
+
+```
+
+Here is the structure of the `CtrlExMemFlow`:
+```
+    plan, memory_files, memory_content, goal
+                |
+                v
+        +---------------+
+        |  Controller   | --------<<<<-----------+
+        +---------------+                        |
+                |                                |
+                | (command, command args)        |
+                |                                |
+                v                                |
+        +------------------+                     |
+        |   Executor       |  Each branch is an  |
+        | (Tree Structure) |  executor           |
+        +------------------+                     |
+                |                                ^
+                | (execution results)            ^
+                |                                ^
+                v                                ^
+        +---------------+                        ^
+        | MemWriteFlow  |  Updates memory files  ^
+        +---------------+                        ^
+                |                                ^
+                | (summary)                      |
+                |                                |
+                v                                |
+        +---------------+                        |
+        | MemReadFlow   |  Reads updated memory  |
+        +---------------+                        |
+                |                                |
+                | (updated memory content)       |
+                |                                |
+                +-> goes back to the Controller>-+
+
+```
+Structure of the Executors:
+```
+                 +-------------------+
+                 |   Branching       |
+                 |    Executor       |
+                 +-------------------+
+        /          |     |          |      \
+       /           |     |          |       \
+      /            |     |          |        \
+     /             |     |          |         \
+write_code    ask_user re_plan update_plan   save_code
+
+```
+
+Memory files of ExtendLibraryFlow:
+- plan_extlib.txt
+- logs_extlib.txt
+- library.py
+
+About the branches:
+- [write_code](https://huggingface.co/Tachi67/CodeWriterFlowModule): Generates code in an interactive way, the user is able to edit or provide feedback during the process of writing code.
+- [ask_user](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py): Ask user for info / confirmation, etc.
+- [re_plan](https://huggingface.co/Tachi67/ReplanningFlowModule): One branch of the executors, when something goes wrong, re-draft the plan.
+- [update_plan](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/UpdatePlanAtomicFlow.py): One branch of the executors, when the controller realizes that one (or some, depending on the LLM's response) step of the plan is (are) done, it generates a new plan that marks the step(s) as done.
+- [save_code](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/SaveCodeAtomicFlow.py): Writes the wriiten & tested code to the code library.
+
+
+# Table of Contents
+
+* [SaveCodeAtomicFlow](#SaveCodeAtomicFlow)
+  * [SaveCodeAtomicFlow](#SaveCodeAtomicFlow.SaveCodeAtomicFlow)
+    * [run](#SaveCodeAtomicFlow.SaveCodeAtomicFlow.run)
+* [ExtLibAskUserFlow](#ExtLibAskUserFlow)
+  * [ExtLibAskUserFlow](#ExtLibAskUserFlow.ExtLibAskUserFlow)
+* [ExtendLibraryFlow](#ExtendLibraryFlow)
+  * [ExtendLibraryFlow](#ExtendLibraryFlow.ExtendLibraryFlow)
+* [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow)
+  * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow)
+* [run\_ExtendLibrary](#run_ExtendLibrary)
+* [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib)
+  * [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib.CtrlExMem_ExtLib)
+* [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib)
+  * [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib.ControllerFlow_ExtLib)
+* [\_\_init\_\_](#__init__)
+
+<a id="SaveCodeAtomicFlow"></a>
+
+# SaveCodeAtomicFlow
+
+<a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow"></a>
+
+## SaveCodeAtomicFlow Objects
+
+```python
+class SaveCodeAtomicFlow(AtomicFlow)
+```
+
+This flow appends the code to the code library file.
+*Input Interface*:
+- `code` (str): the code to be appended to the code library
+- `memory_files` (dict): the dictionary of memory files
+
+*Output Interface*:
+- `result` (str): the result of the flow, to be returned to the controller of the caller
+- `summary` (str): the summary of the flow, to be appended to logs
+
+<a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+Run the flow
+
+**Arguments**:
+
+- `input_data`: the input data
+
+**Returns**:
+
+the output data
+
+<a id="ExtLibAskUserFlow"></a>
+
+# ExtLibAskUserFlow
+
+<a id="ExtLibAskUserFlow.ExtLibAskUserFlow"></a>
+
+## ExtLibAskUserFlow Objects
+
+```python
+class ExtLibAskUserFlow(HumanStandardInputFlow)
+```
+
+This class is used to ask for user feedback whenever the controller is unsure of something, or need confirmation, etc.
+
+*Expected Input*:
+- `question`: The question asked by the controller
+
+*Expected Behaviour*:
+- The question is displayed, and the user gives feedback by inputing string.
+
+*Expected Ouput*:
+- `result`: The input of the user.
+- `summary`: The summary that will be written by the caller.
+
+<a id="ExtendLibraryFlow"></a>
+
+# ExtendLibraryFlow
+
+<a id="ExtendLibraryFlow.ExtendLibraryFlow"></a>
+
+## ExtendLibraryFlow Objects
+
+```python
+class ExtendLibraryFlow(AbstractBossFlow)
+```
+
+ExtendLibraryFlow is one branch executor of CoderFlow. At a higher level, it takes the goal
+from the Coder, writes functions in an interactive way, test the code and append the newly written function to
+the code library.
+
+Workflow of ExtendLibrary:
+0. Coder calls ExtendLibrary with a goal.
+1. MemoryReading reads logs, plan, and code library.
+2. Planner makes a plan based on the goal.
+3. Write code in an interactive fashion.
+4. Test code.
+5. Finish, writes code to the library.
+Step 3-5 is done via prompting the controller.
+
+*Input Interface (expected input)*
+- `goal` (str): The goal from the caller (source flow, i.e. CoderFlow)
+*Output Interface (expected output)*
+- `result` (str): The result of the flow, the result will be returned to the caller (i.e. CoderFlow).
+- `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow (i.e. CoderFlow).
+
+<a id="UpdatePlanAtomicFlow"></a>
+
+# UpdatePlanAtomicFlow
+
+<a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow"></a>
+
+## UpdatePlanAtomicFlow Objects
+
+```python
+class UpdatePlanAtomicFlow(AtomicFlow)
+```
+
+Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py
+
+<a id="run_ExtendLibrary"></a>
+
+# run\_ExtendLibrary
+
+<a id="CtrlExMem_ExtLib"></a>
+
+# CtrlExMem\_ExtLib
+
+<a id="CtrlExMem_ExtLib.CtrlExMem_ExtLib"></a>
+
+## CtrlExMem\_ExtLib Objects
+
+```python
+class CtrlExMem_ExtLib(CtrlExMemFlow)
+```
+
+This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
+See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+*Input Interface*:
+- `plan`
+- `logs`
+- `memory_files`
+- `goal`
+*Output Interface*
+- `result` (str): The result of the flow, the result will be returned to the caller.
+- `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow.
+
+<a id="ControllerFlow_ExtLib"></a>
+
+# ControllerFlow\_ExtLib
+
+<a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib"></a>
+
+## ControllerFlow\_ExtLib Objects
+
+```python
+class ControllerFlow_ExtLib(ChatAtomicFlow)
+```
+
+Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py
+
+<a id="__init__"></a>
+
+# \_\_init\_\_
+

SaveCodeAtomicFlow.py

@@ -0,0 +1,58 @@
+from typing import Dict, Any
+from aiflows.base_flows.atomic import AtomicFlow
+
+
+class SaveCodeAtomicFlow(AtomicFlow):
+    """This flow appends the code to the code library file.
+    *Input Interface*:
+    - `code` (str): the code to be appended to the code library
+    - `memory_files` (dict): the dictionary of memory files
+    
+    *Output Interface*:
+    - `result` (str): the result of the flow, to be returned to the controller of the caller
+    - `summary` (str): the summary of the flow, to be appended to logs
+    """
+    def _check_input(self, input_data: Dict[str, Any]):
+        """Check if the input data is valid
+        :param input_data: the input data
+        :return: None
+        """
+        assert "code" in input_data, "code is not passed to SaveCodeAtomicFlow"
+        assert "memory_files" in input_data, "memory_files is not passed to SaveCodeFlow"
+        assert "code_library" in input_data["memory_files"], "code_library not in memory_files"
+        # create the code library if it doesn't exist yet
+        code_library_location = input_data["memory_files"]["code_library"]
+        with open(code_library_location, 'a') as file:
+            pass
+
+    def _call(self, input_data: Dict[str, Any]):
+        """The internal logic of the flow
+        :param input_data: the input data
+        :return: the output data
+        """
+        try:
+            code_to_append = input_data["code"]
+            code_lib_loc = input_data["memory_files"]["code_library"]
+            with open(code_lib_loc, 'a') as file:
+                file.write(code_to_append + '\n')
+            return {
+                "result": "code successfully written to the library",
+                "summary": f"ExtendLibrayFlow/SaveCodeAtomicFlow: code written to {code_lib_loc}"
+            }
+        except Exception as e:
+            error_msg = str(e)
+            return {
+                "result": f"error occurred: {error_msg}",
+                "summary": f"ExtendLibrayFlow/SaveCodeAtomicFlow: error occurred: {error_msg}"
+            }
+
+    def run(
+            self,
+            input_data: Dict[str, Any]
+    ):
+        """Run the flow
+        :param input_data: the input data
+        :return: the output data
+        """
+        self._check_input(input_data)
+        return self._call(input_data)

SaveCodeAtomicFlow.yaml

@@ -0,0 +1,11 @@
+_target_: aiflows.ExtendLibraryFlowModule.SaveCodeAtomicFlow.instantiate_from_default_config
+name: "SaveCodeAtomicFlow"
+description: "In extend library flow, once the code is written and tested, the controller calls this flow to save the code to the library."
+
+input_interface:
+  - "memory_files"
+  - "code"
+
+output_interface:
+  - "result"
+  - "summary"

UpdatePlanAtomicFlow.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any
+from aiflows.base_flows.atomic import AtomicFlow
+class UpdatePlanAtomicFlow(AtomicFlow):
+    """Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py"""
+    def _check_input(self, input_data: Dict[str, Any]):
+        assert "memory_files" in input_data, "memory_files not passed to UpdatePlanAtomicFlow"
+        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"ExtendLibrary/UpdatePlanFlow: updated plan saved to {plan_file_location}"
+            }
+        except Exception as e:
+            return {
+                "result": f"Error occurred: {str(e)}",
+                "summary": f"ExtendLibrary/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_: flow_modules.aiflows.ExtendLibraryFlowModule.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,18 @@
+dependencies = [
+    {"url": "aiflows/AbstractBossFlowModule", "revision": "main"},
+    {"url": "aiflows/MemoryReadingFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanWriterFlowModule", "revision": "main"},
+    {"url": "aiflows/ReplanningFlowModule", "revision": "main"},
+    {"url": "aiflows/CodeWriterFlowModule", "revision": "main"},
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "4ff043522c89a964ea3a928ce09811c51a2b5b98"},
+    {"url": "aiflows/ChatFlowModule", "revision": "297c90d08087d9ff3139521f11d1a48d7dc63ed4"},
+]
+
+from aiflows import flow_verse
+flow_verse.sync_dependencies(dependencies)
+from .ControllerFlow_ExtLib import ControllerFlow_ExtLib
+from .CtrlExMem_ExtLib import CtrlExMem_ExtLib
+from .ExtendLibraryFlow import ExtendLibraryFlow
+from .ExtLibAskUserFlow import ExtLibAskUserFlow
+from .SaveCodeAtomicFlow import SaveCodeAtomicFlow
+from .UpdatePlanAtomicFlow import UpdatePlanAtomicFlow

pip_requirements.txt

@@ -0,0 +1,15 @@
+colorama==0.4.6
+pytest==7.3.1
+pytest-cov==4.1.0
+hydra-core==1.3.2
+hydra-colorlog==1.1.0
+wrapt-timeout-decorator==1.3.12.2
+diskcache==5.6.1
+openai==1.0.0
+huggingface_hub==0.19.4
+jsonlines==3.1.0
+jinja2==3.1.2
+mock==5.0.2
+rich==12.6.0
+litellm==1.0.0
+aiflows

run_ExtendLibrary.py

@@ -0,0 +1,81 @@
+import os
+
+import hydra
+
+from aiflows.backends.api_info import ApiInfo
+from aiflows.messages import InputMessage
+from aiflows.utils.general_helpers import read_yaml_file
+
+from aiflows import logging
+from aiflows.flow_cache import CACHING_PARAMETERS, clear_cache
+from aiflows.utils.general_helpers import quick_load
+
+CACHING_PARAMETERS.do_caching = False  # Set to True in order to disable caching
+# clear_cache() # Uncomment this line to clear the cache
+
+logging.set_verbosity_debug()
+logging.auto_set_dir()
+
+dependencies = [
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "4ff043522c89a964ea3a928ce09811c51a2b5b98"},
+    {"url": "aiflows/ChatFlowModule", "revision": "297c90d08087d9ff3139521f11d1a48d7dc63ed4"},
+    {"url": "aiflows/ExtendLibraryFlowModule", "revision": "main"},
+    {"url": "aiflows/AbstractBossFlowModule", "revision": "main"},
+    {"url": "aiflows/MemoryReadingFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanWriterFlowModule", "revision": "main"},
+    {"url": "aiflows/ReplanningFlowModule", "revision": "main"},
+    {"url": "aiflows/CodeWriterFlowModule", "revision": "main"},
+]
+
+from aiflows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+
+if __name__ == "__main__":
+    # ~~~ make sure to set the openai api key in the envs ~~~
+    key = os.getenv("OPENAI_API_KEY")
+    api_information = [ApiInfo(backend_used="openai", api_key=os.getenv("OPENAI_API_KEY"))]
+    path_to_output_file = None
+
+    current_dir = os.getcwd()
+    cfg_path = os.path.join(current_dir, "ExtendLibraryFlow.yaml")
+    cfg = read_yaml_file(cfg_path)
+    # ~~~ setting api information into config ~~~
+    quick_load(cfg, api_information)
+
+    # ~~~ setting memory files into config ~~~
+    code_lib_file_loc = os.path.join(current_dir, "library.py")
+    plan_file_loc = os.path.join(current_dir, "plan_extlib.txt")
+    logs_file_loc = os.path.join(current_dir, "logs_extlib.txt")
+    with open(code_lib_file_loc, 'w') as file:
+        pass
+    with open(plan_file_loc, 'w') as file:
+        pass
+    with open(logs_file_loc, 'w') as file:
+        pass
+    memfiles_extlib = {}
+    memfiles_writecode_interactivecoder = {}
+    memfiles_writecode_test = {}
+    memfiles_extlib["plan"] = plan_file_loc
+    memfiles_extlib["logs"] = logs_file_loc
+    memfiles_extlib["code_library"] = code_lib_file_loc
+    memfiles_writecode_interactivecoder["code_library"] = code_lib_file_loc
+    memfiles_writecode_test["code_library"] = code_lib_file_loc
+    cfg["memory_files"] = memfiles_extlib
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["write_code"]["subflows_config"]["Executor"]["subflows_config"]["write_code"]["memory_files"] = memfiles_writecode_interactivecoder
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["write_code"]["subflows_config"]["Executor"]["subflows_config"]["test"]["memory_files"] = memfiles_writecode_test
+
+
+    # ~~~ instantiating the flow and input data ~~~
+    ExtendLibraryFlow = hydra.utils.instantiate(cfg, _recursive_=False, _convert_="partial")
+    input_data = {
+        "goal": "Write a function that adds up two numbers",
+    }
+    input_message = InputMessage.build(
+        data_dict=input_data,
+        src_flow="Launcher",
+        dst_flow=ExtendLibraryFlow.name
+    )
+
+    # ~~~ calling the flow ~~~
+    output_message = ExtendLibraryFlow(input_message)