Init commit: migrate JarvisFlow from Tachi67/JarvisFlowModule to aiflows

Controller_JarvisFlow.py

@@ -0,0 +1,159 @@
+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]
+
+# TODO: controller should be generalized
+class Controller_JarvisFlow(ChatAtomicFlow):
+    """This class is a controller for JarvisFlow, it takes the plan generated by the planner, logs of previous executions,
+    depending on the initial goal or the subsequent feedback from the branching executors (and the human), to decide which
+    executor to call next (or to exit by calling finish).
+
+    *Configuration Parameters*:
+    - `commands` (dict): a dictionary of commands that the controller can call, each command has a name, a description, and a list of input arguments.
+        The commands will be injected into the system message prompt template.
+    - `system_message_prompt_template` (str): the template for the system message prompt, there are several components needs to be injected into the
+        template, including the commands, plan, plan_file_location, logs, and the goal. The injection of commands is done then initalizing the flow,
+        the rest of the components are injected at the beginning of each run.
+    - `previous_messages` (int): a sliding window of previous messages that will be passed to the model. This is the central part of short-term memory management.
+
+    *Input Interface Non Initialized*:
+    - `goal` (str): the initial goal of the conversation, this is the input to the model.
+    - `memory_files` (dict): a dictionary of file locations that contains the plan, logs.
+    - `plan` (str): the plan generated by the planner, the plan will change (marked as done, or re-plan) as execution preceeds.
+    - `logs` (str): the logs of previous executions, the logs will be appended as execution preceeds.
+
+    *Input Interface Initialized*:
+    - `result` (str): the result of the previous execution, this is the input to the model.
+    - `memory_files` (dict): a dictionary of file locations that contains the plan, logs.
+    - `plan` (str): the plan generated by the planner, the plan will change (marked as done, or re-plan) as execution preceeds.
+    - `logs` (str): the logs of previous executions, the logs will be appended as execution preceeds.
+    - `goal` (str): the initial goal, this is kept because the goal is also injected into the system prompts so that Jarvis does not
+        forget what the goal is, when the memory sliding window is implemented.
+
+    *Output Interface*:
+    - `command` (str): the command to be executed by the executor.
+    - `command_args` (dict): the arguments of the command to be executed by the executor.
+    """
+    def __init__(
+            self,
+            commands: List[Command],
+            **kwargs):
+        """Initialize the flow, inject the commands into the system message prompt template."""
+        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 plan file 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_content_file_location(self, input_data, content_name):
+        # get the location of the file that contains the content: plan, logs, code_library
+        assert "memory_files" in input_data, "memory_files not passed to Jarvis/Controller"
+        assert content_name in input_data["memory_files"], f"{content_name} not in memory files"
+        return input_data["memory_files"][content_name]
+
+    def _get_content(self, input_data, content_name):
+        # get the content of the file that contains the content: plan, logs, code_library
+        assert content_name in input_data, f"{content_name} not passed to Jarvis/Controller"
+        content = input_data[content_name]
+        if len(content) == 0:
+            content = f'No {content_name} yet'
+        return content
+    @staticmethod
+    def _build_commands_manual(commands: List[Command]) -> str:
+        """Build the manual for the commands."""
+        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
+
+
+    @classmethod
+    def instantiate_from_config(cls, config):
+        """Setting up the flow from the config file. In particular, setting up the prompts, backend, and commands."""
+        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]):
+        """Hinting the model to output in json format, updating the plan, logs to the system prompts."""
+        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_content_file_location(input_data, "plan")
+        plan_content = self._get_content(input_data, "plan")
+        logs_content = self._get_content(input_data, "logs")
+        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"])
+
+        # ~~~run the model, special mechanism to deal with situations where the output is not in json format. ~~~
+        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 (ValueError, 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

Controller_JarvisFlow.yaml

@@ -0,0 +1,155 @@
+_target_: Tachi67.JarvisFlowModule.Controller_JarvisFlow.instantiate_from_default_config
+name: "ControllerFlow_JarvisFlow"
+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:
+  Coder:
+    description: "Instruct the coder to write and run code to finish your given goal."
+    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: "When one step of the plan is done, pass the updated plan to edit plan file and override current plan"
+    input_args: [ "updated_plan" ]
+  intermediate_answer:
+    description: "When one step of the plan is done, pass the result from the step as an intermediate answer to the user"
+    input_args: [ "answer" ]
+  final_answer:
+    description: "When the goal is achieved, pass the result from the goal as a final answer to the user"
+    input_args: [ "answer" ]
+
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+          Your department is in charge of achieving a particular goal by writing and running code. You are the leader of the department.
+    
+          Here is the goal you need to achieve:
+            {{goal}}
+          
+          You work with several subordinates, they will be in charge of the specific tasks, including writing and running code to achieve a goal given specifically by you, 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 stored at {{plan_file_location}}. Here is the plan:
+            {{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 can be achieved by writing and running code, call `Coder` with the goal of the current step of plan.
+          2. Whenever you have done one step of the plan, do the following:
+            2.1 Reflect on what plan you are having right now.
+            2.2 Reflect on which step of the plan you just finished.
+            2.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**
+            2.4 Call `update_plan` with the plan you just generated.
+          3. After you finish one step of the plan and have called `update_plan`, call `intermediate_answer` with the result of the step you just finished.
+          4. The user will provide you with feedback on the last step executed, react accordingly.
+          5. If the user is happy with the intermediate result, proceed to the next step of the plan, go back to workflow 1.
+          5. When every step of the plan is done:
+            5.1 Call `final_answer` with the result of the goal.
+            5.2 React to the user's feedback, if the user is not happy, you may want to re-plan or give new instructions to the coder.
+            5.3 If the user is happy, call `finish` with a summary of what was done throughout the process.
+
+          **You MUST call `update_plan` whenever you realize one step of the plan is done.**
+          **You MUST call `finish` whenever everything is done and the user is happy.**
+          
+          Here is an example of execution:  
+          ### Beginning of an example execution: ###
+          Plan: 1. Download the weather data from Paris on 19. Dec. 2021. 2. Send the weather data to an email address. 3. Give a final answer.
+          Your actions:
+          1. Call `Coder` with the goal of the first step of the plan. Code is written and run, the weather data is downloaded.
+          2. You call `update_plan` with the plan you just generated, it is exactly the same as the plan you have now, but with the current step of plan marked as done.
+          3. You call `intermediate_answer` with the result of the step you just finished.
+          4. The user is happy with the intermediate result, you proceed to the next step of the plan.
+          5. Call `Coder` with the goal of the second step of the plan. Code is written and run, the weather data is sent to an email address.
+          6. You call `update_plan` with the plan you just generated, it is exactly the same as the plan you have now, but with the current step of plan marked as done.
+          7. You call `intermediate_answer` with the result of the step you just finished.
+          8. The user is happy with the intermediate result, you proceed to the next step of the plan.
+          9. Call `final_answer` with the result of the goal.
+          10. The user is happy with the final result, you call `finish` with a summary of what was done throughout the process.
+          ### 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", "logs", "plan_file_location", "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_JarvisFlow.py

@@ -0,0 +1,68 @@
+from typing import Dict, Any
+
+from flow_modules.Tachi67.AbstractBossFlowModule import CtrlExMemFlow
+from aiflows.base_flows import CircularFlow
+
+
+class CtrlExMem_JarvisFlow(CtrlExMemFlow):
+    """This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
+    See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+    Take notice that:
+    1. In the controller, we only keep the previous 3 messages for memory management, that will be:
+        a. The assistant message (controller's last command)
+        b. Manually updated new system prompt (new logs, new plans, etc.)
+        c. The user message (result, feedback)
+    2. Each time one executor from the branch is executed, the logs is updated, this means:
+        a. The logs file of Jarvis is updated.
+        b. After MemoryReading at the end of each run of the loop, the logs in the flow_state is updated.
+        c. The next time the controller is called, the updated logs is injected into the system prompts.
+    3. In the prompts of the controller, when the controller realizes one step of the plan is done, 
+        we ask the controller to revise what was done and mark the current step as done. This means:
+        a. The plan file is updated.
+        b. The plan in the flow_state is updated.
+        c. The next time the controller is called, the updated plan is injected into the system prompts.
+    
+    This is basically how the memory management works, to allow for more space for llm execution, and make sure the llm
+    does not forget important information.
+    """
+    def _on_reach_max_round(self):
+        self._state_update_dict({
+            "result": "the maximum amount of rounds was reached before the Jarvis flow has done the job",
+            "summary": "JarvisFlow: 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": "Jarvis: " + output_payload["command_args"]["summary"],
+                "status": "finished"
+            }
+        elif command == "manual_finish":
+            # ~~~ return the manual quit status ~~~
+            return {
+                "EARLY_EXIT": True,
+                "result": "JarvisFlow was terminated explicitly by the user, process is unfinished",
+                "summary": "Jarvis: 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_JarvisFlow.yaml

@@ -0,0 +1,223 @@
+_target_: Tachi67.JarvisFlowModule.CtrlExMem_JarvisFlow.instantiate_from_default_config
+name: "CtrlExMem_JarvisFlow"
+description: "MemorizedControllerExecutor flow for Jarvis flow"
+
+input_interface:
+  - "plan"
+  - "logs"
+  - "memory_files"
+  - "goal"
+
+subflows_config:
+  Controller:
+    _target_: Tachi67.JarvisFlowModule.Controller_JarvisFlow.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:
+      Coder:
+        _target_: Tachi67.CoderFlowModule.CoderFlow.instantiate_from_default_config
+        memory_files: ???
+        subflows_config:
+          Planner:
+            #TODO remove this line
+            _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:
+            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
+      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
+      update_plan:
+        _target_: Tachi67.JarvisFlowModule.UpdatePlanAtomicFlow.instantiate_from_default_config
+      intermediate_answer:
+        _target_: Tachi67.JarvisFlowModule.IntermediateAns_Jarvis.instantiate_from_default_config
+      final_answer:
+        _target_: Tachi67.JarvisFlowModule.FinalAns_Jarvis.instantiate_from_default_config
+
+
+  MemoryReading:
+    _target_: Tachi67.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    output_interface:
+      - "plan"
+      - "logs"
+
+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_JarvisFlow.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.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

FinalAns_Jarvis.py

@@ -0,0 +1,35 @@
+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__}")
+
+
+class FinalAns_Jarvis(HumanStandardInputFlow):
+    """This class inherits from the HumanStandardInputFlow class.
+    It is used to give the final answer to the user.
+    """
+    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()
+
+        answer = input_data["answer"]
+        response = {}
+        response["result"] = human_input
+        response["summary"] = f"Final answer provided: {answer}; feedback of user: {human_input}"
+
+        return response

FinalAns_Jarvis.yaml

@@ -0,0 +1,9 @@
+_target_: Tachi67.JarvisFlowModule.FinalAns_Jarvis.instantiate_from_default_config
+request_multi_line_input_flag: False
+end_of_input_string: EOI
+
+query_message_prompt_template:
+  template: |2-
+    Jarvis has just achieved the goal, here is the final answer: {{answer}}
+  input_variables:
+    - "answer"

IntermediateAns_Jarvis.py

@@ -0,0 +1,36 @@
+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__}")
+
+
+class IntermediateAns_Jarvis(HumanStandardInputFlow):
+    """This class inherits from the HumanStandardInputFlow class.
+    It is used to give an intermediate answer to the user. The user is then able to provide feedback on the intermediate result.
+    Depending on the user's feedback, the controller will decide to do different things (e.g. continue, re-plan, etc.)
+    """
+    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()
+
+        answer = input_data["answer"]
+        response = {}
+        response["result"] = human_input
+        response["summary"] = f"Intermediate Answer provided: {answer}; feedback of user: {human_input}"
+
+        return response

IntermediateAns_Jarvis.yaml

@@ -0,0 +1,9 @@
+_target_: Tachi67.JarvisFlowModule.IntermediateAns_Jarvis.instantiate_from_default_config
+request_multi_line_input_flag: False
+end_of_input_string: EOI
+
+query_message_prompt_template:
+  template: |2-
+    Jarvis has just finished an intermediate step of execution: {{answer}}
+  input_variables:
+    - "answer"

Introduction_to_Jarvis.md

@@ -0,0 +1,328 @@
+## Introduction to Jarvis
+
+Jarvis is a general purpose agent empowered by a hierarchical structure of large language models and tools including a code interpreter. At a high level, Jarvis takes in tasks in natural language, and achieve the task by making plans, writing and executing code.
+
+
+
+To allow for extended the lifespan of Jarvis (constrained by token limitations of LLM APIs) and enable Jarvis to be able to utilize previously accomplished results, we implemented some interesting memory management mechanisms.
+
+
+**Notice:**
+The code interpreter of Jarvis (https://huggingface.co/Tachi67/InterpreterFlowModule) relies on **open-interpreter** (https://github.com/KillianLucas/open-interpreter). We are extracting the specific code from open-interpreter because the litellm version of open-interpreter is not compatible with that of the current version of aiflows (v.0.1.7).
+
+
+
+### Structure of Jarvis
+
+Let's cut things short, here is an illustration of the Jarvis architecture:
+```
+     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       |
+             +-------------------+
+        /     |     |     |     |      \
+       /      |     |     |     |       \
+      /       |     |     |     |        \
+     /        |     |     |     |         \
+Coder  ask_user re_plan update_plan intermediate_answer final_answer
+
+```
+
+In fact, this structure is defined as [AbstractBoss](https://huggingface.co/Tachi67/AbstractBossFlowModule), Jarvis inherits from this abstract flow. There are other components that
+inherits from this structure. for example, [Coder](https://huggingface.co/Tachi67/CoderFlowModule), [ExtendLibrary](https://huggingface.co/Tachi67/ExtendLibraryFlowModule)
+
+Let's go through some basic ideas of Jarvis and its components now.
+- memory: Jarvis should remember certain important memory, they include the plan (`plan`), and the history of subflows execution results (`logs`). To do this, we put them in external files, and inject them into the system prompts to controllers and other corresponding roles. There are other classes that inherits from `AbstractBoss` and have other memories, e.g. `Coder` takes the memory of `code_libarary`, which is the function signatures and docstrings of the code written by the Coder and saved in the code library.
+- memory_files: A dictionary: `{memory_name: memory_file_path}`
+- [MemoryReadingFlow](https://huggingface.co/Tachi67/MemoryReadingFlowModule): Reads in the content of the memory files.
+- [PlanWriter](https://huggingface.co/Tachi67/PlanWriterFlowModule): Writes a step-by-step plan to achieve the goal in an interactive fashion. During the process of writing a plan, the user has the chance to provide feedback to or directly edit the plan just written. The PlanWriter can comprehend the user's action and make adjustments to the plan accordingly.
+- [CtrlExMem_JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/CtrlExMem_JarvisFlow.py): Inherits from [CtrlExMemFlow](https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py), it executes the step-by-step plan written by the PlanWriter in a controller-executor fashion, with memory management mechanisms.
+- [Controller of CtrlExMem_JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py): The controller of the CtrlExMem_JarvisFlow. It inherits from [ChatFlowModule](https://huggingface.co/aiflows/ChatFlowModule) (that being said, an LLM API), it decides to either call one of the branching executors or to finish and exit the loop.
+- [Coder](https://huggingface.co/Tachi67/CoderFlowModule): One branch of the executors, it writes functions that are reusable to the code library (Python), writes and run code scripts of execute logics like executing one function from the library, installing packages, 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.
+- [ask_user](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py): One branch of the executors, when the controller needs user assist, confirmation, etc., it calls this flow.
+- [intermediate_answer](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/IntermediateAns_Jarvis.py): One branch of the executors, when one (or some, depending on the LLM's response) step of the plan is (are) done, the controller calls this flow to remind the user that the step(s) is (are) done, and ask for the user's feedback.
+- [final_answer](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/FinalAns_Jarvis.py): One branch of the executors, when the plan is done, the controller calls this flow to remind the user that the plan is done, and ask for the user's feedback.
+- [MemWriteFlow](https://huggingface.co/Tachi67/MemoryWritingFlowModule): Updates memory files (`logs`).
+- [MemReadFlow](https://huggingface.co/Tachi67/MemoryReadingFlowModule): Reads updated memory files (`plan`,`logs`).
+
+
+### Memory Management Mechanisms
+Above all, the role separation into a hierarchy structure of LLMs largely increases the token upper limits.
+
+For long-term memory, the goal is to refine the quality of LLM's chat history, to do this, we utilize memory files, for now there are three kinds of memory_files:
+- `plan`: the step-by-step plan to achieve the goal, it will be updated by the `update_plan` executor when the controller realizes that one (or some, depending on the LLM's response) step of the plan is (are) done.
+- `logs`: the history of subflows execution results, it will be updated by the `MemWriteFlow` executor whenever one branching executor is finished.
+- `code_library`: the function signatures and docstrings of the code written by the Coder and saved in the code library, it will be updated by the `Coder` executor whenever the Coder writes a new function to the code library.
+
+The memory contents are injected into the system prompts of the respective LLM chats.
+
+We also applied a sliding window for history chat messages as a workaround for the token limitations of the LLM APIs. To do this:
+- Whenever the chat that utilizes the sliding window is called, we inject a new system prompt with the newest memory (plan, logs, for `Coder` and some other flows, `code_library` is also injected) into the chat history.)
+- We crop the chat history with a tailing window of length 3, that will include the assistant's previous call, the updated system prompt, the the user's new response.
+
+When the `Coder` and `ExtendLibraryFlow` is finished, we reset the flows, that means the chat history is cleaned as well -- which is fine, because the plan and logs are preserved in the upper level of flow (`JarvisFlow` and `Coder`). By doing this, Jarvis is able to clear useless tokens.
+
+As a result, Jarvis is able to run for quite a long time, and it's able to use the code written before.
+
+### An Example run of Jarvis
+WARNING: This section is quite lengthy. Also, due to the nondeterministic nature of the LLMs, the results may vary, the reader is suggested to make sure every plan and piece of code does the same thing as the example presents.
+
+- user input goal = "Download tesla's stock prices from 2022-01-01 to 2022-06-01 from yfinance, plot the prices."
+- Plan of Jarvis is generated, the user is able to edit the plan directly or give feedback.
+    
+    Plan (Jarvis):
+    1. Write and run code to download Tesla's stock prices from 2022-01-01 to 2022-06-01 using python package yfinance.
+    2. Write and run code to plot the downloaded stock prices using matplotlib.
+    3. Give a final answer to the user.
+- Controller of Jarvis calls Coder.
+- Planner of Coder generates plan of Coder, the user is able to edit the plan directly or give feedback.
+  
+    Plan (Coder):
+    1. Extend the code library with a function named `download_stock_data`. This function should take three parameters: `ticker_symbol` (a string representing the stock's ticker symbol), `start_date` (a string representing the start date in the format 'YYYY-MM-DD'), and `end_date` (a string representing the end date in the same format). The function should use the `yfinance` library to download the stock data for the given ticker symbol between the start and end dates, and return this data as a pandas DataFrame.
+
+    2. Run a code script to import the `yfinance` library. If the library is not already installed, the script should install it using pip.
+
+    3. Run a code script to import the `download_stock_data` function from the code library.
+
+    4. Run a code script to call the `download_stock_data` function with the inputs 'TSLA', '2022-01-01', and '2022-06-01'. The script should store the returned DataFrame in a variable.
+
+    5. Give a final answer: the data is stored in a variable, specify the variable name.
+
+- The Controller of Coder calls ExtendLibraryFlow.
+- Planner of ExtendLibrary generates plan of ExtendLibraryFlow, the user is able to edit the plan directly or give feedback.
+    
+    Plan (ExtendLibrary):
+    1. Write a function named 'download_stock_data'. This function should take three parameters: 'ticker_symbol' (a string), 'start_date' (a string in the format 'YYYY-MM-DD'), and 'end_date' (a string in the same format). Inside the function, use the 'yfinance.download' method from the 'yfinance' library to download the stock data for the given ticker symbol between the start and end dates. The 'yfinance.download' method should be called with the 'ticker_symbol' as the first argument, 'start_date' as the second argument and 'end_date' as the third argument. The function should return the downloaded data as a pandas DataFrame.
+
+
+- The Controller of ExtendLibrary calls write_code, inside of write_code flow:
+  -  The code gets generated, and the user is able to provide feedback on the code or edit the code directly.
+
+    Code:
+    ```python
+    def download_stock_data(ticker_symbol: str, start_date: str, end_date: str):
+        """
+        Downloads the stock data for the given ticker symbol between the start and end dates.
+
+        Parameters:
+        ticker_symbol (str): The ticker symbol of the stock.
+        start_date (str): The start date in the format 'YYYY-MM-DD'.
+        end_date (str): The end date in the format 'YYYY-MM-DD'.
+
+        Returns:
+        pandas.DataFrame: The downloaded stock data.
+        """
+        import yfinance
+
+        # Download the stock data
+        data = yfinance.download(ticker_symbol, start=start_date, end=end_date)
+
+        return data
+    ```
+  -  The code is tested, before testing the code, the user is able to provide test suites to test the code, otherwise only the syntax of the code is checked. Here we do not provide any other test suites.
+- The Controller calls save_code to append the newly written function to the code library.
+- The Controller of ExtendLibrary calls update_plan to mark the step of plan as done.
+- The Controller of ExtendLibrary finishes ExtendLibraryFlow, going back to the coder.
+- When finishing the ExtendLibraryFlow, it is reseted, setting its flow_state and the flow_state of its subflows as an empty dict.
+- The Controller of Coder calls update_plan to mark step 1 of the plan as done.
+- The Controller of Coder calls run_code to proceed step 2 of the plan. The code to run is generated by the Controller of Coder.
+- Inside of run_code, the following is executed:
+  - The code is written to a temp file.
+  ```shell
+  pip install yfinance
+  ```
+  - The temp file is opened in a vscode session.
+  - The user is able to edit the code.
+  - Code is ran by an interpreter.
+  - The result is logged to the console, the user is able to provide feedback on the execution result.
+  - Exit back to Coder.
+
+- The Controller of Coder calls run_code to proceed step 3 of the plan.
+- Code to import function is executed, the user is able to provide feedback.
+    
+    ```python
+    import importlib
+    import library
+    importlib.reload(library)
+    from library import download_stock_data
+    ```
+- The Controller of Coder calls run_code to proceed step 4 of the plan.
+- Code to download the data is executed. User is able to provide feedback on the results.
+  
+  ```python
+  stock_data = download_stock_data('TSLA', '2022-01-01', '2022-06-01')
+  ```
+- The Controller of Coder calls update_plan to mark the rest steps of the plan as done.
+- The Controller finishes the Coder flow and return result to the JarvisFlow.
+- When finishing, the CoderFlow resets, setting its flow_state and the flow_state of its subflows an an empty dict.
+- The Controller of Jarvis calls update_plan to mark step 1 of the plan as done.
+- The Controller of Jarvis calls Coder with the goal of the second step of plan.
+- The Planner of Coder makes a plan:
+    
+    Plan:
+   1. Extend the code library with a function to plot the stock prices. The function should take a pandas DataFrame (which is the output of the download_stock_data function) as input and plot the 'Close' prices against the dates. The function should not return anything. The function should be named 'plot_stock_prices'. 
+   2. Import the 'download_stock_data' and 'plot_stock_prices' functions from the code library. 
+   3. Run the 'download_stock_data' function with the desired ticker symbol, start date, and end date to get the stock data. 
+   4. Run the 'plot_stock_prices' function with the DataFrame obtained from the previous step as input to plot the stock prices. 
+   5. The final answer is the plot generated by the 'plot_stock_prices' function. function.
+
+- The plan is passed to the Controller of Coder, the Controller of Coder calls ExtendLibrary.
+- The Planner of ExtendLibrary makes the following plan:
+  
+    Plan:
+    1. Write a function named 'plot_stock_prices'. This function should take in a pandas DataFrame as a parameter, which is the output of the 'download_stock_data' function. Inside the function, use matplotlib or any other plotting library to plot the 'Close' prices against the dates. The function should not return anything.
+
+- The Controller of ExtendLibrary calls write_code to write and test the code. Still, we do not provide any more test suites other than checking syntax.
+    ```python
+    def plot_stock_prices(df):
+    """
+    Plots the 'Close' prices against the dates.
+
+    Parameters:
+    df (pandas.DataFrame): The DataFrame containing the stock data.
+    """
+    import matplotlib.pyplot as plt
+
+    plt.figure(figsize=(10,5))
+    plt.plot(df.index, df['Close'], label='Close Price history') 
+    plt.xlabel('Date')
+    plt.ylabel('Close Price')
+    plt.title('Close Price Trend')
+    plt.legend()
+    plt.show()
+    ```
+
+- The Controller of ExtendLibrary calls save_code to append the function to the code library.
+- The Controller of ExtendLibrary calls update_plan to mark the step of plan as done.
+- The Controller of ExtendLibrary finishes the flow and resets the flow and its subflows.
+- The Controller of Coder calls update_plan to mark the first step of the plan as done.
+- The Controller of Coder calls run_code to proceed to the second step of the plan.
+  
+  ```python
+  import importlib
+    import library
+    importlib.reload(library)
+    from library import download_stock_data, plot_stock_prices
+  ```
+- The Controller calls update_plan to mark the second step of plan as done.
+- The Controller calls run_code to proceed the thrid step of the plan.
+
+    ```python
+    stock_data = download_stock_data('TSLA', '2022-01-01', '2022-06-01')
+    ```
+- The Controller of Coder callss run_code to proceed the 4th step of the plan.
+
+    ```python
+    plot_stock_prices(stock_data)
+    ```
+- Plot is generated.
+- The Controller of Coder updates the rest of the plan as done.
+- The Controller of Coder finishes the CoderFlow, reset the flow and go back to Jarvis.
+- The Controller of Jarvis updates the plan to mark the second step of plan as done.
+- The Controller of Jarvis calls final_ans to provide the final answer.
+- The Controller of Jarvis finishes the Jarvis flow.
+
+
+### Future Improvements
+Due to time constraints, we were not able to refine Jarvis to the very best, here is a list of TODOs:
+- When running code tests in [TestCodeFlow](https://huggingface.co/Tachi67/TestCodeFlowModule) we should show the test results to the user and parse for feedback. This can be done by adding a subflow to ask for human feedback (like [this](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/IntermediateAns_Jarvis.py)) to [TestCodeFlow](https://huggingface.co/Tachi67/TestCodeFlowModule/blob/main/TestCodeFlow.py).
+
+- Consider refactoring:
+    - Controllers should be generalized:
+        - [Controller of JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py)
+        - [Controller of CoderFlow](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ControllerFlow_ExtLib.py)
+        - [Controller of ExtendLibraryFlow](https://huggingface.co/Tachi67/CoderFlowModule/blob/main/Controller_CoderFlow.py)
+        - [Controller of PlanWriterFlow](https://huggingface.co/Tachi67/PlanWriterFlowModule/blob/main/PlanWriterCtrlFlow.py)
+        - [Controller of CodeWriterFlow](https://huggingface.co/Tachi67/CodeWriterFlowModule/blob/main/CodeWriterFlow.py)
+    - AskUserFlow should be generalized:
+        - [IntermediateAns of JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/IntermediateAns_Jarvis.py)
+        - [FinalAns of JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/FinalAns_Jarvis.py)
+        - AskUserFlow of each controller
+    - Planners should be generalized:
+        basically, modify [PlanWriterFlow](https://huggingface.co/Tachi67/PlanWriterFlowModule/tree/main) to make it adapted to:
+        - [Planner of JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Planner_JarvisFlow.py)
+        - [Planner of CoderFlow](https://huggingface.co/Tachi67/CoderFlowModule/blob/main/Planner_CoderFlow.py)
+    - UpdatePlanFlow should be generalized:
+        - [UpdatePlanFlow of JarvisFlow](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/UpdatePlanAtomicFlow.py)
+        - [UpdatePlanFlow of CoderFlow](https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py)
+        - [UpdatePlanFlow of ExtendLibraryFlow](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/UpdatePlanAtomicFlow.py)
+- Clear up prompts to use more examples instead of natural language instructions.
+- During the execution of a flow, the user should be press `Crtl + C` to exit the current flow and go back to the caller flow. By doing this, the user should also be able to provide feedback to the controller of the caller flow to instruct what to do next.
+- After replanning, the controller sometimes gets confused of the new plan, it may be because that we are simply overriding the plan injected to the system prompts. Consider providing the controller a user message informing it of the new plan (please take notice of the sliding window as it's kind of tricky.)
+
+
+### Acknowledgement and some nonesense
+**WARNING:** This section is not related to the design, implementaion nor usage of Jarvis, the reader can completely skip this section without losing any useful information.
+
+Jarvis is done independently as a semester project by [Haolong Li](https://github.com/Tachi-67) ([haolong.li@epfl.ch](mailto:haolong.li@epfl.ch)) at EPFL, very special and strong thanks to his mentor: Martin Josifoski, and semi-mentor: Nicolas Baldwin (I'm not posting their contacts in case they get mad ;-) ) for their help and support during the design and implementation of Jarvis, love you!
+
+Jarvis is built under the framework of [aiflows](https://github.com/epfl-dlab/aiflows), it's cool -- try it out!
+
+Jarvis is not perfect, December in Switzerland (or EPFL? who knows) sucks, the poor author didn't got the energy to write super clean code, but it runs!! ;) 

JarvisFlow.py

@@ -0,0 +1,32 @@
+from flow_modules.Tachi67.AbstractBossFlowModule import AbstractBossFlow
+
+class JarvisFlow(AbstractBossFlow):
+    """JarvisFlow is a flow module for the boss Jarvis. It inherits from AbstractBossFlow. (
+    https://huggingface.co/Tachi67/AbstractBossFlowModule/tree/main). Jarvis is a general purpose agent empowered by
+    multiple large language models and tools including a code interpreter, to take task commands in natural language,
+    and make plans, write and run code in an interactive fashion to finish the task.
+
+    The highlight of Jarvis is that it integrates 17 large language models, each of them prompted differently to achieve
+    seamless inter-model communication and model-user interaction. The structure of Jarvis ensures that it is much more
+    robust, flexible and memory-efficient than previous agents empowered by one single model.
+    What's more, Jarvis integrates modules to allow for llm's memory management, ensuring persisted mid-long term memory
+    and efficient short-term memory management, making its life duration much longer than single-modeled agents,
+    and more powerful, in that it is able to accumulate important knowledge e.g. code library. Jarvis can also take
+    response from the user and the environment (e.g. code execution result), and spontaneously re-plan and re-execute
+    to make the execution more robust and reliable.
+
+    *Configuration Parameters*:
+    - `memory_files` (dict): mem_name-memfile_path pairs. mem_name is the name of the memory (plan, logs, code_library),
+       and memfile_path is the path to the corresponding memory file. Configure this either in the .yaml file, or override
+       the `memory_files` entry when running the flow.
+    - `subflows_config` (dict): configs for subflows.
+        - `MemoryReading`: Module used to read in memory (https://huggingface.co/Tachi67/MemoryReadingFlowModule), output interface
+           configured so that it outputs the neeed memory.
+        - `Planner`: Module used to interactively write plans for Jarvis, the planner is implemented in the JarvisFlow.
+        - `CtrlExMem`: Module used to execute the plan in a controller-executor manner, and update the memory. It is implemented
+           in the JarvisFlow.
+
+    **The code interpreter of Jarvis (https://huggingface.co/Tachi67/InterpreterFlowModule) relies on open-interpreter (https://github.com/KillianLucas/open-interpreter)
+    We are extracting the specific code from open-interpreter because the litellm version of open-interpreter is not compatible with that of the current version of aiflows(v.0.1.7).**
+    """
+    pass

JarvisFlow.yaml

@@ -0,0 +1,182 @@
+name: JarvisFlow
+description: Jarvis, an agent with structured llms and tools able to process user requests, write and execute code, with external memory mechanisms.
+
+_target_: Tachi67.JarvisFlowModule.JarvisFlow.instantiate_from_default_config
+
+memory_files: ???
+
+subflows_config:
+  MemoryReading:
+    _target_: Tachi67.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    output_interface:
+      - "plan"
+      - "logs"
+
+  Planner:
+    _target_: Tachi67.JarvisFlowModule.Planner_JarvisFlow.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.JarvisFlowModule.CtrlExMem_JarvisFlow.instantiate_from_default_config
+    subflows_config:
+      Controller:
+        backend:
+          api_infos: ???
+          model_name:
+            openai: gpt-4
+            azure: azure/gpt-4
+      Executor:
+        subflows_config:
+          Coder:
+            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:
+                      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
+          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

Planner_JarvisFlow.py

@@ -0,0 +1,64 @@
+from typing import Dict, Any
+import os
+from flow_modules.Tachi67.PlanWriterFlowModule import PlanWriterFlow
+from aiflows.base_flows import CircularFlow
+
+class Planner_JarvisFlow(PlanWriterFlow):
+    """This flow inherits from PlanWriterFlow (https://huggingface.co/Tachi67/PlanWriterFlowModule), and is used to generate a plan for Jarvis.
+    *Input Interface*:
+    - `goal` (str): the goal of the planner, the goal comes from the user's query when calling Jarvis.
+    - `memory_files` (dict): a dictionary of memory files, the keys are the names of the memory files, the values are the locations of the memory files.
+
+    *Output Interfaces*:
+    - `plan` (str): the generated plan, the plan string will be written to the plan file and returned to the flow state of the Jarvis flow.
+    - `summary` (str): the summary of the planner.
+    - `status` (str): the status of the planner, can be "finished" or "unfinished".
+    """
+    # TODO: generalize this flow to avoid code duplication
+    @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": "Jarvis/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": "Jarvis/PlanWriter: PlanWriter was terminated explicitly by the user, process is unfinished",
+                "status": "unfinished"
+            }
+        elif command == "write_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"]["plan_file_location"] = fetched_state["memory_files"]["plan"]
+            return output_payload
+        else:
+            return output_payload

Planner_JarvisFlow.yaml

@@ -0,0 +1,117 @@
+name: "Planner/Jarvis"
+description: "Generates plan with interactions with the user, used for the coder class"
+
+_target_: Tachi67.JarvisFlowModule.Planner_JarvisFlow.instantiate_from_default_config
+
+input_interface:
+  - "goal"
+  - "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_: aiflows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      write_plan:
+        subflows_config:
+          PlanGenerator:
+            backend:
+              api_infos: ???
+              model_name:
+                openai: gpt-4
+                azure: azure/gpt-4
+            system_message_prompt_template:
+              _target_: aiflows.prompt_template.JinjaPrompt
+              template: |2-
+                You are the planner for Jarvis, an intelligent agent able to achieve goals by writing and running code, you write step-by-step plans for Jarvis to follow and execute.
+
+                Jarvis is capable of:
+                  1. Generating and running code, given a goal.
+                  2. Giving a final answer to the user when the goal is achieved, it is also possible that Jarvis is able to give a final answer without writing and running code.
+                
+                **Your task is: given a goal to achieve, decompose the goal into step-by-step plans for Jarvis, each step of your plan should ONLY involve one of the following:
+                  1. Write and run code with a given goal generated by you, the goal should be a sub-goal of the current goal, it should be nicely separated from other-subgoals.
+                  2. 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 either writing & running code, or giving a final answer.
+                  2. Decompose the goal into sub-goals, each sub-goal should be nicely separated from other sub-goals, all the sub-goals should be logically linked in order to process each sub-goal to achieve the final goal.
+                
+                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 either writing & running code or giving a final answer.
+                  3. You should make plans with as few steps as possible.
+                
+                
+                **Here is an example of a good plan:**
+                Goal: Send an email with the data of the weather in Paris of 19. Dec. 2021 to my friend.
+                Plan:
+                  1. Write and run code to get the data of the weather in Paris of 19. Dec. 2021.
+                  2. Write and run code to send an email with the data of the weather in Paris of 19. Dec. 2021 to my friend.
+                  3. Give a final answer to the user.
+
+                **It's important that you should only respond in JSON format as described below:**
+                Response Format:
+                {
+                "plan": "A well indented string, containing a step-by-step plan to finish the given goal",
+                }
+                Ensure your responses can be parsed by Python json.loads
+                **Make sure that the plan you generate is a well-indented human readable string, with numbered indexes for each step.**
+
+          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_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface:
+      _target_: Planner_JarvisFlow.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.plan: plan
+        branch_output_data.feedback: feedback
+        branch_output_data.temp_plan_file_location: temp_plan_file_location
+      keys_to_delete: ["branch_output_data"]
+    reset: false

README.md

@@ -0,0 +1,234 @@
+# Table of Contents
+
+* [JarvisFlow](#JarvisFlow)
+  * [JarvisFlow](#JarvisFlow.JarvisFlow)
+* [Controller\_JarvisFlow](#Controller_JarvisFlow)
+  * [Controller\_JarvisFlow](#Controller_JarvisFlow.Controller_JarvisFlow)
+    * [\_\_init\_\_](#Controller_JarvisFlow.Controller_JarvisFlow.__init__)
+    * [instantiate\_from\_config](#Controller_JarvisFlow.Controller_JarvisFlow.instantiate_from_config)
+* [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow)
+  * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow)
+* [Planner\_JarvisFlow](#Planner_JarvisFlow)
+  * [Planner\_JarvisFlow](#Planner_JarvisFlow.Planner_JarvisFlow)
+* [run\_Jarvis](#run_Jarvis)
+* [CtrlExMem\_JarvisFlow](#CtrlExMem_JarvisFlow)
+  * [CtrlExMem\_JarvisFlow](#CtrlExMem_JarvisFlow.CtrlExMem_JarvisFlow)
+* [\_\_init\_\_](#__init__)
+* [IntermediateAns\_Jarvis](#IntermediateAns_Jarvis)
+  * [IntermediateAns\_Jarvis](#IntermediateAns_Jarvis.IntermediateAns_Jarvis)
+* [FinalAns\_Jarvis](#FinalAns_Jarvis)
+  * [FinalAns\_Jarvis](#FinalAns_Jarvis.FinalAns_Jarvis)
+
+<a id="JarvisFlow"></a>
+
+# JarvisFlow
+
+<a id="JarvisFlow.JarvisFlow"></a>
+
+## JarvisFlow Objects
+
+```python
+class JarvisFlow(AbstractBossFlow)
+```
+
+JarvisFlow is a flow module for the boss Jarvis. It inherits from AbstractBossFlow. (
+https://huggingface.co/Tachi67/AbstractBossFlowModule/tree/main). Jarvis is a general purpose agent empowered by
+multiple large language models and tools including a code interpreter, to take task commands in natural language,
+and make plans, write and run code in an interactive fashion to finish the task.
+
+The highlight of Jarvis is that it integrates 17 large language models, each of them prompted differently to achieve
+seamless inter-model communication and model-user interaction. The structure of Jarvis ensures that it is much more
+robust, flexible and memory-efficient than previous agents empowered by one single model.
+What's more, Jarvis integrates modules to allow for llm's memory management, ensuring persisted mid-long term memory
+and efficient short-term memory management, making its life duration much longer than single-modeled agents,
+and more powerful, in that it is able to accumulate important knowledge e.g. code library. Jarvis can also take
+response from the user and the environment (e.g. code execution result), and spontaneously re-plan and re-execute
+to make the execution more robust and reliable.
+
+*Configuration Parameters*:
+- `memory_files` (dict): mem_name-memfile_path pairs. mem_name is the name of the memory (plan, logs, code_library),
+   and memfile_path is the path to the corresponding memory file. Configure this either in the .yaml file, or override
+   the `memory_files` entry when running the flow.
+- `subflows_config` (dict): configs for subflows.
+    - `MemoryReading`: Module used to read in memory (https://huggingface.co/Tachi67/MemoryReadingFlowModule), output interface
+       configured so that it outputs the neeed memory.
+    - `Planner`: Module used to interactively write plans for Jarvis, the planner is implemented in the JarvisFlow.
+    - `CtrlExMem`: Module used to execute the plan in a controller-executor manner, and update the memory. It is implemented
+       in the JarvisFlow.
+
+**The code interpreter of Jarvis (https://huggingface.co/Tachi67/InterpreterFlowModule) relies on open-interpreter (https://github.com/KillianLucas/open-interpreter)
+We are extracting the specific code from open-interpreter because the litellm version of open-interpreter is not compatible with that of the current version of aiflows(v.0.1.7).**
+
+<a id="Controller_JarvisFlow"></a>
+
+# Controller\_JarvisFlow
+
+<a id="Controller_JarvisFlow.Controller_JarvisFlow"></a>
+
+## Controller\_JarvisFlow Objects
+
+```python
+class Controller_JarvisFlow(ChatAtomicFlow)
+```
+
+This class is a controller for JarvisFlow, it takes the plan generated by the planner, logs of previous executions,
+depending on the initial goal or the subsequent feedback from the branching executors (and the human), to decide which
+executor to call next (or to exit by calling finish).
+
+*Configuration Parameters*:
+- `commands` (dict): a dictionary of commands that the controller can call, each command has a name, a description, and a list of input arguments.
+    The commands will be injected into the system message prompt template.
+- `system_message_prompt_template` (str): the template for the system message prompt, there are several components needs to be injected into the
+    template, including the commands, plan, plan_file_location, logs, and the goal. The injection of commands is done then initalizing the flow,
+    the rest of the components are injected at the beginning of each run.
+- `previous_messages` (int): a sliding window of previous messages that will be passed to the model. This is the central part of short-term memory management.
+
+*Input Interface Non Initialized*:
+- `goal` (str): the initial goal of the conversation, this is the input to the model.
+- `memory_files` (dict): a dictionary of file locations that contains the plan, logs.
+- `plan` (str): the plan generated by the planner, the plan will change (marked as done, or re-plan) as execution preceeds.
+- `logs` (str): the logs of previous executions, the logs will be appended as execution preceeds.
+
+*Input Interface Initialized*:
+- `result` (str): the result of the previous execution, this is the input to the model.
+- `memory_files` (dict): a dictionary of file locations that contains the plan, logs.
+- `plan` (str): the plan generated by the planner, the plan will change (marked as done, or re-plan) as execution preceeds.
+- `logs` (str): the logs of previous executions, the logs will be appended as execution preceeds.
+- `goal` (str): the initial goal, this is kept because the goal is also injected into the system prompts so that Jarvis does not
+    forget what the goal is, when the memory sliding window is implemented.
+
+*Output Interface*:
+- `command` (str): the command to be executed by the executor.
+- `command_args` (dict): the arguments of the command to be executed by the executor.
+
+<a id="Controller_JarvisFlow.Controller_JarvisFlow.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(commands: List[Command], **kwargs)
+```
+
+Initialize the flow, inject the commands into the system message prompt template.
+
+<a id="Controller_JarvisFlow.Controller_JarvisFlow.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config)
+```
+
+Setting up the flow from the config file. In particular, setting up the prompts, backend, and commands.
+
+<a id="UpdatePlanAtomicFlow"></a>
+
+# UpdatePlanAtomicFlow
+
+<a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow"></a>
+
+## UpdatePlanAtomicFlow Objects
+
+```python
+class UpdatePlanAtomicFlow(AtomicFlow)
+```
+
+This class is used to update the plan file with the updated plan, called by the controlller,
+when it realizes one step of the plan is done, and provide the updated plan, it is exactly the same
+as the old plan, except the step that is done is marked as done.
+
+<a id="Planner_JarvisFlow"></a>
+
+# Planner\_JarvisFlow
+
+<a id="Planner_JarvisFlow.Planner_JarvisFlow"></a>
+
+## Planner\_JarvisFlow Objects
+
+```python
+class Planner_JarvisFlow(PlanWriterFlow)
+```
+
+This flow inherits from PlanWriterFlow (https://huggingface.co/Tachi67/PlanWriterFlowModule), and is used to generate a plan for Jarvis.
+*Input Interface*:
+- `goal` (str): the goal of the planner, the goal comes from the user's query when calling Jarvis.
+- `memory_files` (dict): a dictionary of memory files, the keys are the names of the memory files, the values are the locations of the memory files.
+
+*Output Interfaces*:
+- `plan` (str): the generated plan, the plan string will be written to the plan file and returned to the flow state of the Jarvis flow.
+- `summary` (str): the summary of the planner.
+- `status` (str): the status of the planner, can be "finished" or "unfinished".
+
+<a id="run_Jarvis"></a>
+
+# run\_Jarvis
+
+<a id="CtrlExMem_JarvisFlow"></a>
+
+# CtrlExMem\_JarvisFlow
+
+<a id="CtrlExMem_JarvisFlow.CtrlExMem_JarvisFlow"></a>
+
+## CtrlExMem\_JarvisFlow Objects
+
+```python
+class CtrlExMem_JarvisFlow(CtrlExMemFlow)
+```
+
+This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
+See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+Take notice that:
+1. In the controller, we only keep the previous 3 messages for memory management, that will be:
+    a. The assistant message (controller's last command)
+    b. Manually updated new system prompt (new logs, new plans, etc.)
+    c. The user message (result, feedback)
+2. Each time one executor from the branch is executed, the logs is updated, this means:
+    a. The logs file of Jarvis is updated.
+    b. After MemoryReading at the end of each run of the loop, the logs in the flow_state is updated.
+    c. The next time the controller is called, the updated logs is injected into the system prompts.
+3. In the prompts of the controller, when the controller realizes one step of the plan is done, 
+    we ask the controller to revise what was done and mark the current step as done. This means:
+    a. The plan file is updated.
+    b. The plan in the flow_state is updated.
+    c. The next time the controller is called, the updated plan is injected into the system prompts.
+
+This is basically how the memory management works, to allow for more space for llm execution, and make sure the llm
+does not forget important information.
+
+<a id="__init__"></a>
+
+# \_\_init\_\_
+
+<a id="IntermediateAns_Jarvis"></a>
+
+# IntermediateAns\_Jarvis
+
+<a id="IntermediateAns_Jarvis.IntermediateAns_Jarvis"></a>
+
+## IntermediateAns\_Jarvis Objects
+
+```python
+class IntermediateAns_Jarvis(HumanStandardInputFlow)
+```
+
+This class inherits from the HumanStandardInputFlow class.
+It is used to give an intermediate answer to the user. The user is then able to provide feedback on the intermediate result.
+Depending on the user's feedback, the controller will decide to do different things (e.g. continue, re-plan, etc.)
+
+<a id="FinalAns_Jarvis"></a>
+
+# FinalAns\_Jarvis
+
+<a id="FinalAns_Jarvis.FinalAns_Jarvis"></a>
+
+## FinalAns\_Jarvis Objects
+
+```python
+class FinalAns_Jarvis(HumanStandardInputFlow)
+```
+
+This class inherits from the HumanStandardInputFlow class.
+It is used to give the final answer to the user.
+

UpdatePlanAtomicFlow.py

@@ -0,0 +1,34 @@
+#TODO: generalize updateplanatomicflow with the one in extendlibrary
+from typing import Dict, Any
+from aiflows.base_flows.atomic import AtomicFlow
+class UpdatePlanAtomicFlow(AtomicFlow):
+    """This class is used to update the plan file with the updated plan, called by the controlller,
+    when it realizes one step of the plan is done, and provide the updated plan, it is exactly the same
+    as the old plan, except the step that is done is marked as done.
+    """
+    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"Jarvis/UpdatePlanFlow: updated plan saved to {plan_file_location}"
+            }
+        except Exception as e:
+            return {
+                "result": f"Error occurred: {str(e)}",
+                "summary": f"Jarvis/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.JarvisFlowModule.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,23 @@
+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": "Tachi67/CoderFlowModule", "revision": "main"},
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "4ff043522c89a964ea3a928ce09811c51a2b5b98"},
+    {"url": "aiflows/ChatFlowModule", "revision": "297c90d08087d9ff3139521f11d1a48d7dc63ed4"},
+]
+
+from aiflows import flow_verse
+flow_verse.sync_dependencies(dependencies)
+
+from .UpdatePlanAtomicFlow import UpdatePlanAtomicFlow
+from .JarvisFlow import JarvisFlow
+from .Controller_JarvisFlow import Controller_JarvisFlow
+from .Planner_JarvisFlow import Planner_JarvisFlow
+from .FinalAns_Jarvis import FinalAns_Jarvis
+from .IntermediateAns_Jarvis import IntermediateAns_Jarvis
+from .CtrlExMem_JarvisFlow import CtrlExMem_JarvisFlow
+

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