add more comments & docs, typo fix

Controller_JarvisFlow.py

@@ -14,7 +14,6 @@ class Command:
     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
@@ -50,7 +49,12 @@ class Controller_JarvisFlow(ChatAtomicFlow):
             self,
             commands: List[Command],
             **kwargs):
-        """Initialize the flow, inject the commands into the system message prompt template."""
+        """Initialize the flow, inject the commands into the system message prompt template.
+        :param commands: a list of commands that the controller can call.
+        :type commands: List[Command]
+        :param kwargs: other parameters.
+        :type kwargs: Dict[str, Any]
+        """
         super().__init__(**kwargs)
         self.system_message_prompt_template = self.system_message_prompt_template.partial(
             commands=self._build_commands_manual(commands),
@@ -70,12 +74,31 @@ class Controller_JarvisFlow(ChatAtomicFlow):
         """
 
     def _get_content_file_location(self, input_data, content_name):
+        """
+        Get the location of the file that contains the content: plan, logs, code_library
+        :param input_data: the input data to the flow
+        :type input_data: Dict[str, Any]
+        :param content_name: the name of the content
+        :type content_name: str
+        :raises AssertionError: if the content is not in the memory_files
+        :raises AssertionError: if memory_files is not passed to the flow
+        :return: the location of the file that contains the content
+        """
         # 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
+        :param input_data: the input data to the flow
+        :type input_data: Dict[str, Any]
+        :param content_name: the name of the content
+        :type content_name: str
+        :raises AssertionError: if the content is not in the input_data
+        :return: the content of the file that contains the content
+        """
         # 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]
@@ -84,7 +107,12 @@ class Controller_JarvisFlow(ChatAtomicFlow):
         return content
     @staticmethod
     def _build_commands_manual(commands: List[Command]) -> str:
-        """Build the manual for the commands."""
+        """Build the manual for the commands.
+        :param commands: a list of commands that the controller can call.
+        :type commands: List[Command]
+        :return: the manual for the commands.
+        :rtype: str
+        """
         ret = ""
         for i, command in enumerate(commands):
             command_input_json_schema = json.dumps(
@@ -95,7 +123,12 @@ class Controller_JarvisFlow(ChatAtomicFlow):
 
     @classmethod
     def instantiate_from_config(cls, config):
-        """Setting up the flow from the config file. In particular, setting up the prompts, backend, and commands."""
+        """Setting up the flow from the config file. In particular, setting up the prompts, backend, and commands.
+        :param config: the config file.
+        :type config: Dict[str, Any]
+        :return: the instantiated flow.
+        :rtype: Controller_JarvisFlow
+        """
         flow_config = deepcopy(config)
 
         kwargs = {"flow_config": flow_config}
@@ -118,7 +151,10 @@ class Controller_JarvisFlow(ChatAtomicFlow):
         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."""
+        """Hinting the model to output in json format, updating the plan, logs to the system prompts.
+        :param input_data: the input data to the flow.
+        :type input_data: Dict[str, Any]
+        """
         if 'goal' in input_data:
             input_data['goal'] += self.hint_for_model
         if 'result' in input_data:
@@ -133,6 +169,12 @@ class Controller_JarvisFlow(ChatAtomicFlow):
         )
 
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Run the flow, update the system prompts, and run the model.
+        :param input_data: the input data to the flow.
+        :type input_data: Dict[str, Any]
+        :return: the output of the flow.
+        :rtype: Dict[str, Any]
+        """
         self._update_prompts_and_input(input_data)
 
         # ~~~when conversation is initialized, append the updated system prompts to the chat history ~~~

CtrlExMem_JarvisFlow.py

@@ -6,7 +6,23 @@ 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
+    See: https://huggingface.co/aiflows/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+    *Input Interface*:
+    - `plan`
+    - `memory_files`
+    - `logs`
+    - `goal`
+
+    *Output Interface*:
+    - `result`
+    - `summary`
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the flow
+    - `output_interface`: the output interface of the flow
+    - `subflows_config`: the subflows configuration of the flow
+    - `topology`: the topology of the subflows
 
     Take notice that:
     1. In the controller, we only keep the previous 3 messages for memory management, that will be:
@@ -27,6 +43,8 @@ class CtrlExMem_JarvisFlow(CtrlExMemFlow):
     does not forget important information.
     """
     def _on_reach_max_round(self):
+        """This function is called when the maximum amount of rounds is reached before the Jarvis flow has done the job.
+        """
         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",
@@ -35,6 +53,15 @@ class CtrlExMem_JarvisFlow(CtrlExMemFlow):
 
     @CircularFlow.output_msg_payload_processor
     def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        """This function is called when the JarvisFlow receives a message from one of its branches. This function
+        processes the message and decides whether the JarvisFlow should continue or finish.
+        :param output_payload: the output payload of the branch
+        :type output_payload: Dict[str, Any]
+        :param src_flow: the source flow of the message
+        :type src_flow: str
+        :return: the updated output payload
+        :rtype: Dict[str, Any]
+        """
         command = output_payload["command"]
         if command == "finish":
             return {

FinalAns_Jarvis.py

@@ -12,10 +12,28 @@ 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.
+
+    *Input Interface*:
+    - `answer`: The answer to the question asked by the user.
+
+    *Output Interface*:
+    - `result`: User's response to the final answer.
+    - `summary`: A summary of the action.
+
+    *Configuration parameters*:
+    - `query_message_prompt_template`: The template of the message that is shown to the user.
+    - `request_multi_line_input_flag`: A flag that indicates whether the user can give a multi-line input.
+    - `end_of_input_string`: The string that indicates the end of the input.
+
     """
     def run(self,
             input_data: Dict[str, Any]) -> Dict[str, Any]:
-
+        """The run method of the class.
+        :param input_data: The input data of the flow.
+        :type input_data: Dict[str, Any]
+        :return: The output data of the flow.
+        :rtype: 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'],

IntermediateAns_Jarvis.py

@@ -13,6 +13,19 @@ 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.)
+
+    *Input Interface*:
+    - `answer`: The intermediate answer to the question asked by the user.
+
+    *Output Interface*:
+    - `result`: User's response to the intermediate answer.
+    - `summary`: A summary of the action.
+
+    *Configuration parameters*:
+    - `query_message_prompt_template`: The template of the message that is shown to the user.
+    - `request_multi_line_input_flag`: A flag that indicates whether the user can give a multi-line input.
+    - `end_of_input_string`: The string that indicates the end of the input.
+
     """
     def run(self,
             input_data: Dict[str, Any]) -> Dict[str, Any]:

JarvisFlow.py

@@ -2,7 +2,7 @@ from flow_modules.aiflows.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
+    https://huggingface.co/aiflows/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.
 
@@ -20,13 +20,13 @@ class JarvisFlow(AbstractBossFlow):
        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
+        - `MemoryReading`: Module used to read in memory (https://huggingface.co/aiflows/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)
+    **The code interpreter of Jarvis (https://huggingface.co/aiflows/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

Planner_JarvisFlow.py

@@ -4,7 +4,7 @@ from flow_modules.aiflows.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.
+    """This flow inherits from PlanWriterFlow (https://huggingface.co/aiflows/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.
@@ -13,10 +13,26 @@ class Planner_JarvisFlow(PlanWriterFlow):
     - `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".
+
+    *Configuration Parameters*:
+    - Also refer to PlanWriterFlow (https://huggingface.co/aiflows/PlanWriterFlowModule/blob/main/PlanWriterFlow.py) for more configuration parameters.
+    - `input_interface`: the input interface of the flow.
+    - `output_interface`: the output interface of the flow.
+    - `subflows_config`: the configuration of the subflows of the flow.
+    - `early_exit_key`: the key of the early exit signal in the output payload.
+    - `topology`: the topology of the subflows.
+
     """
-    # 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]:
+        """This function is used to detect whether the planner should finish or continue.
+        :param output_payload: the output payload of the flow.
+        :type output_payload: Dict[str, Any]
+        :param src_flow: the flow that generates the output payload.
+        :type src_flow: Flow
+        :return: the output payload of the flow.
+        :rtype: 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

README.md

@@ -1,5 +1,6 @@
 **For a detailed introduction to Jarvis, including Jarvis structures, an example run, etc, visit: https://huggingface.co/aiflows/JarvisFlowModule/blob/main/Introduction_to_Jarvis.md**
 
+
 # Table of Contents
 
 * [JarvisFlow](#JarvisFlow)
@@ -8,18 +9,23 @@
   * [Controller\_JarvisFlow](#Controller_JarvisFlow.Controller_JarvisFlow)
     * [\_\_init\_\_](#Controller_JarvisFlow.Controller_JarvisFlow.__init__)
     * [instantiate\_from\_config](#Controller_JarvisFlow.Controller_JarvisFlow.instantiate_from_config)
+    * [run](#Controller_JarvisFlow.Controller_JarvisFlow.run)
 * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow)
   * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow)
+    * [run](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow.run)
 * [Planner\_JarvisFlow](#Planner_JarvisFlow)
   * [Planner\_JarvisFlow](#Planner_JarvisFlow.Planner_JarvisFlow)
+    * [detect\_finish\_or\_continue](#Planner_JarvisFlow.Planner_JarvisFlow.detect_finish_or_continue)
 * [run\_Jarvis](#run_Jarvis)
 * [CtrlExMem\_JarvisFlow](#CtrlExMem_JarvisFlow)
   * [CtrlExMem\_JarvisFlow](#CtrlExMem_JarvisFlow.CtrlExMem_JarvisFlow)
+    * [detect\_finish\_or\_continue](#CtrlExMem_JarvisFlow.CtrlExMem_JarvisFlow.detect_finish_or_continue)
 * [\_\_init\_\_](#__init__)
 * [IntermediateAns\_Jarvis](#IntermediateAns_Jarvis)
   * [IntermediateAns\_Jarvis](#IntermediateAns_Jarvis.IntermediateAns_Jarvis)
 * [FinalAns\_Jarvis](#FinalAns_Jarvis)
   * [FinalAns\_Jarvis](#FinalAns_Jarvis.FinalAns_Jarvis)
+    * [run](#FinalAns_Jarvis.FinalAns_Jarvis.run)
 
 <a id="JarvisFlow"></a>
 
@@ -34,7 +40,7 @@ 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
+https://huggingface.co/aiflows/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.
 
@@ -52,13 +58,13 @@ to make the execution more robust and reliable.
    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
+    - `MemoryReading`: Module used to read in memory (https://huggingface.co/aiflows/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)
+**The code interpreter of Jarvis (https://huggingface.co/aiflows/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>
@@ -113,6 +119,11 @@ def __init__(commands: List[Command], **kwargs)
 
 Initialize the flow, inject the commands into the system message prompt template.
 
+**Arguments**:
+
+- `commands` (`List[Command]`): a list of commands that the controller can call.
+- `kwargs` (`Dict[str, Any]`): other parameters.
+
 <a id="Controller_JarvisFlow.Controller_JarvisFlow.instantiate_from_config"></a>
 
 #### instantiate\_from\_config
@@ -124,6 +135,32 @@ def instantiate_from_config(cls, config)
 
 Setting up the flow from the config file. In particular, setting up the prompts, backend, and commands.
 
+**Arguments**:
+
+- `config` (`Dict[str, Any]`): the config file.
+
+**Returns**:
+
+`Controller_JarvisFlow`: the instantiated flow.
+
+<a id="Controller_JarvisFlow.Controller_JarvisFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+Run the flow, update the system prompts, and run the model.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data to the flow.
+
+**Returns**:
+
+`Dict[str, Any]`: the output of the flow.
+
 <a id="UpdatePlanAtomicFlow"></a>
 
 # UpdatePlanAtomicFlow
@@ -136,10 +173,38 @@ Setting up the flow from the config file. In particular, setting up the prompts,
 class UpdatePlanAtomicFlow(AtomicFlow)
 ```
 
-This class is used to update the plan file with the updated plan, called by the controlller,
+This class is used to update the plan file with the updated plan, called by the controller,
 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.
 
+*Input Interface*:
+- `updated_plan`: the updated plan, exactly the same as the old plan, except the step that is done is marked as done.
+
+*Output Interface*:
+- `result`: the result of the operation
+
+*Configuration Parameters*:
+- `input_interface`: the input interface of the atomic flow
+- `output_interface`: the output interface of the atomic flow
+
+<a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any])
+```
+
+Run the atomic flow.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): the input data
+
+**Returns**:
+
+`Dict[str, Any]`: the result of the operation
+
 <a id="Planner_JarvisFlow"></a>
 
 # Planner\_JarvisFlow
@@ -152,7 +217,7 @@ as the old plan, except the step that is done is marked as done.
 class Planner_JarvisFlow(PlanWriterFlow)
 ```
 
-This flow inherits from PlanWriterFlow (https://huggingface.co/Tachi67/PlanWriterFlowModule), and is used to generate a plan for Jarvis.
+This flow inherits from PlanWriterFlow (https://huggingface.co/aiflows/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.
@@ -162,6 +227,35 @@ This flow inherits from PlanWriterFlow (https://huggingface.co/Tachi67/PlanWrite
 - `summary` (str): the summary of the planner.
 - `status` (str): the status of the planner, can be "finished" or "unfinished".
 
+*Configuration Parameters*:
+- Also refer to PlanWriterFlow (https://huggingface.co/aiflows/PlanWriterFlowModule/blob/main/PlanWriterFlow.py) for more configuration parameters.
+- `input_interface`: the input interface of the flow.
+- `output_interface`: the output interface of the flow.
+- `subflows_config`: the configuration of the subflows of the flow.
+- `early_exit_key`: the key of the early exit signal in the output payload.
+- `topology`: the topology of the subflows.
+
+<a id="Planner_JarvisFlow.Planner_JarvisFlow.detect_finish_or_continue"></a>
+
+#### detect\_finish\_or\_continue
+
+```python
+@CircularFlow.output_msg_payload_processor
+def detect_finish_or_continue(output_payload: Dict[str, Any],
+                              src_flow) -> Dict[str, Any]
+```
+
+This function is used to detect whether the planner should finish or continue.
+
+**Arguments**:
+
+- `output_payload` (`Dict[str, Any]`): the output payload of the flow.
+- `src_flow` (`Flow`): the flow that generates the output payload.
+
+**Returns**:
+
+`Dict[str, Any]`: the output payload of the flow.
+
 <a id="run_Jarvis"></a>
 
 # run\_Jarvis
@@ -179,7 +273,23 @@ class CtrlExMem_JarvisFlow(CtrlExMemFlow)
 ```
 
 This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule.
-See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+See: https://huggingface.co/aiflows/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py
+
+*Input Interface*:
+- `plan`
+- `memory_files`
+- `logs`
+- `goal`
+
+*Output Interface*:
+- `result`
+- `summary`
+
+*Configuration Parameters*:
+- `input_interface`: the input interface of the flow
+- `output_interface`: the output interface of the flow
+- `subflows_config`: the subflows configuration of the flow
+- `topology`: the topology of the subflows
 
 Take notice that:
 1. In the controller, we only keep the previous 3 messages for memory management, that will be:
@@ -199,6 +309,29 @@ Take notice that:
 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="CtrlExMem_JarvisFlow.CtrlExMem_JarvisFlow.detect_finish_or_continue"></a>
+
+#### detect\_finish\_or\_continue
+
+```python
+@CircularFlow.output_msg_payload_processor
+def detect_finish_or_continue(output_payload: Dict[str, Any],
+                              src_flow) -> Dict[str, Any]
+```
+
+This function is called when the JarvisFlow receives a message from one of its branches. This function
+
+processes the message and decides whether the JarvisFlow should continue or finish.
+
+**Arguments**:
+
+- `output_payload` (`Dict[str, Any]`): the output payload of the branch
+- `src_flow` (`str`): the source flow of the message
+
+**Returns**:
+
+`Dict[str, Any]`: the updated output payload
+
 <a id="__init__"></a>
 
 # \_\_init\_\_
@@ -219,6 +352,18 @@ 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.)
 
+*Input Interface*:
+- `answer`: The intermediate answer to the question asked by the user.
+
+*Output Interface*:
+- `result`: User's response to the intermediate answer.
+- `summary`: A summary of the action.
+
+*Configuration parameters*:
+- `query_message_prompt_template`: The template of the message that is shown to the user.
+- `request_multi_line_input_flag`: A flag that indicates whether the user can give a multi-line input.
+- `end_of_input_string`: The string that indicates the end of the input.
+
 <a id="FinalAns_Jarvis"></a>
 
 # FinalAns\_Jarvis
@@ -234,3 +379,33 @@ class FinalAns_Jarvis(HumanStandardInputFlow)
 This class inherits from the HumanStandardInputFlow class.
 It is used to give the final answer to the user.
 
+*Input Interface*:
+- `answer`: The answer to the question asked by the user.
+
+*Output Interface*:
+- `result`: User's response to the final answer.
+- `summary`: A summary of the action.
+
+*Configuration parameters*:
+- `query_message_prompt_template`: The template of the message that is shown to the user.
+- `request_multi_line_input_flag`: A flag that indicates whether the user can give a multi-line input.
+- `end_of_input_string`: The string that indicates the end of the input.
+
+<a id="FinalAns_Jarvis.FinalAns_Jarvis.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+The run method of the class.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): The input data of the flow.
+
+**Returns**:
+
+`Dict[str, Any]`: The output data of the flow.
+

UpdatePlanAtomicFlow.py

@@ -1,16 +1,40 @@
-#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,
+    """This class is used to update the plan file with the updated plan, called by the controller,
     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.
+
+    *Input Interface*:
+    - `updated_plan`: the updated plan, exactly the same as the old plan, except the step that is done is marked as done.
+
+    *Output Interface*:
+    - `result`: the result of the operation
+
+    *Configuration Parameters*:
+    - `input_interface`: the input interface of the atomic flow
+    - `output_interface`: the output interface of the atomic flow
+
     """
     def _check_input(self, input_data: Dict[str, Any]):
+        """
+        Check if the input data is valid.
+        :param input_data: the input data to be checked
+        :type input_data: Dict[str, Any]
+        :raises AssertionError: if the input data is invalid
+        :raises AssertionError: if the input data does not contain the plan file location
+        """
         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]):
+        """
+        Write the updated plan to the plan file.
+        :param input_data: the input data
+        :type input_data: Dict[str, Any]
+        :return: the result of the operation
+        :rtype: Dict[str, Any]
+        """
         try:
             plan_file_location = input_data["memory_files"]["plan"]
             plan_to_write = input_data["updated_plan"]
@@ -30,5 +54,12 @@ class UpdatePlanAtomicFlow(AtomicFlow):
             self,
             input_data: Dict[str, Any]
     ):
+        """
+        Run the atomic flow.
+        :param input_data: the input data
+        :type input_data: Dict[str, Any]
+        :return: the result of the operation
+        :rtype: Dict[str, Any]
+        """
         self._check_input(input_data)
         return self._call(input_data)