Upload 15 files

Controller_JarvisFlow.py

@@ -0,0 +1,111 @@
+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):
+    def __init__(
+            self,
+            commands: List[Command],
+            **kwargs):
+        super().__init__(**kwargs)
+        self.system_message_prompt_template = self.system_message_prompt_template.partial(
+            commands=self._build_commands_manual(commands),
+            plan="no plans yet",
+            plan_file_location="no 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:
+        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):
+        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_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)
+        api_output = super().run(input_data)["api_output"].strip()
+        try:
+            response = json.loads(api_output)
+            return response
+        except json.decoder.JSONDecodeError:
+            new_input_data = input_data.copy()
+            new_input_data['result'] = "The previous respond cannot be parsed with json.loads. Make sure your next response is in JSON format."
+            new_api_output = super().run(new_input_data)["api_output"].strip()
+            return json.loads(new_api_output)

Controller_JarvisFlow.yaml

@@ -0,0 +1,148 @@
+_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:
+  - "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:
+  call_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.
+    
+          You work with several subordinated, 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 `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 `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 `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"]
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the result of your previous action:
+    {{result}}
+  input_variables:
+    - "result"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: flows.prompt_template.JinjaPrompt
+  template: |2-
+    Here is the goal you need to achieve, follow your plan to finish the goal:
+    {{goal}}
+  input_variables:
+    - "goal"
+  template_format: jinja2

CtrlExMem_JarvisFlow.py

@@ -0,0 +1,47 @@
+from typing import Dict, Any
+
+from flow_modules.Tachi67.AbstractBossFlowModule import CtrlExMemFlow
+from flows.base_flows import CircularFlow
+
+
+class CtrlExMem_JarvisFlow(CtrlExMemFlow):
+    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,219 @@
+_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_: flows.base_flows.BranchingFlow.instantiate_from_default_config
+    subflows_config:
+      call_coder:
+        _target_: Tachi67.CoderFlowModule.CoderFlow.instantiate_from_default_config
+        memory_files: ???
+        subflows_config:
+          Planner:
+            _target_: Tachi67.CoderFlowModule.Planner_CoderFlow.instantiate_from_default_config
+            subflows_config:
+              Controller:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+              Executor:
+                subflows_config:
+                  write_plan:
+                    subflows_config:
+                      PlanGenerator:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4
+
+          CtrlExMem:
+            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_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.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_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data: observation
+      keys_to_unpack: ["observation"]
+    reset: false
+
+  - goal: "Write memory to memory files"
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: MemoryWriting
+    reset: false
+
+  - goal: "Read memory from memory files (flow_state)"
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+    flow: MemoryReading
+    reset: false

FinalAns_Jarvis.py

@@ -0,0 +1,32 @@
+from flow_modules.aiflows.HumanStandardInputFlowModule import HumanStandardInputFlow
+
+from typing import Dict, Any
+
+from flows.messages import UpdateMessage_Generic
+
+from flows.utils import logging
+
+log = logging.get_logger(f"flows.{__name__}")
+
+
+class FinalAns_Jarvis(HumanStandardInputFlow):
+    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,32 @@
+from flow_modules.aiflows.HumanStandardInputFlowModule import HumanStandardInputFlow
+
+from typing import Dict, Any
+
+from flows.messages import UpdateMessage_Generic
+
+from flows.utils import logging
+
+log = logging.get_logger(f"flows.{__name__}")
+
+
+class IntermediateAns_Jarvis(HumanStandardInputFlow):
+    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"

JarvisFlow.py

@@ -0,0 +1,4 @@
+from flow_modules.Tachi67.AbstractBossFlowModule import AbstractBossFlow
+
+class JarvisFlow(AbstractBossFlow):
+    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:
+          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
+          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

Planner_JarvisFlow.py

@@ -0,0 +1,54 @@
+from typing import Dict, Any
+import os
+from flow_modules.Tachi67.PlanWriterFlowModule import PlanWriterFlow
+from flows.base_flows import CircularFlow
+
+class Planner_JarvisFlow(PlanWriterFlow):
+    # 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,115 @@
+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_: flows.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_: flows.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 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_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.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_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        branch_output_data: observation
+      keys_to_unpack: ["observation"]
+    reset: false

UpdatePlanAtomicFlow.py

@@ -0,0 +1,30 @@
+#TODO: generalize updateplanatomicflow with the one in extendlibrary
+from typing import Dict, Any
+from flows.base_flows.atomic import AtomicFlow
+class UpdatePlanAtomicFlow(AtomicFlow):
+    def _check_input(self, input_data: Dict[str, Any]):
+        assert "memory_files" in input_data, "memory_files not passed to UpdatePlanAtomicFlow.yaml"
+        assert "plan" in input_data["memory_files"], "plan not in memory_files"
+
+    def _call(self, input_data: Dict[str, Any]):
+        try:
+            plan_file_location = input_data["memory_files"]["plan"]
+            plan_to_write = input_data["updated_plan"]
+            with open(plan_file_location, 'w') as file:
+                file.write(plan_to_write + "\n")
+            return {
+                "result": "updated plan saved to the plan file and has overriden the previous plan",
+                "summary": f"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"