| # Table of Contents | |
| * [Structure of PlanWriterFlow](#structure-of-planwriterflow) | |
| * [run\_planwriter](#run_planwriter) | |
| * [PlanWriterAskUserFlow](#PlanWriterAskUserFlow) | |
| * [PlanWriterAskUserFlow](#PlanWriterAskUserFlow.PlanWriterAskUserFlow) | |
| * [run](#PlanWriterAskUserFlow.PlanWriterAskUserFlow.run) | |
| * [PlanWriterFlow](#PlanWriterFlow) | |
| * [PlanWriterFlow](#PlanWriterFlow.PlanWriterFlow) | |
| * [detect\_finish\_or\_continue](#PlanWriterFlow.PlanWriterFlow.detect_finish_or_continue) | |
| * [run](#PlanWriterFlow.PlanWriterFlow.run) | |
| * [\_\_init\_\_](#__init__) | |
| * [PlanWriterCtrlFlow](#PlanWriterCtrlFlow) | |
| * [PlanWriterCtrlFlow](#PlanWriterCtrlFlow.PlanWriterCtrlFlow) | |
| * [\_\_init\_\_](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.__init__) | |
| * [instantiate\_from\_config](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.instantiate_from_config) | |
| * [run](#PlanWriterCtrlFlow.PlanWriterCtrlFlow.run) | |
| # Structure of PlanWriterFlow | |
| ``` | |
| goal | |
| | | |
| v | |
| +---------------+ | |
| | Controller | --------<<<<-----------+ | |
| +---------------+ | | |
| | | | |
| | (command, command args) | | |
| | | | |
| v | | |
| +------------------+ | | |
| | Executor | Each branch is an | | |
| | (Tree Structure) | executor | | |
| +------------------+ | | |
| | ^ | |
| | (summary) | | |
| | | | |
| v | | |
| | | | |
| +-> goes back to the Controller>-+ | |
| ``` | |
| Structure of the Executors: | |
| ``` | |
| +-------------------+ | |
| | Branching | | |
| | Executor | | |
| +-------------------+ | |
| / \ | |
| / \ | |
| / \ | |
| / \ | |
| write_plan ask_user | |
| ``` | |
| About the branches: | |
| - [ask_user](https://huggingface.co/aiflows/PlanWriterFlowModule/blob/main/PlanWriterAskUserFlow.py): Ask user for info / confirmation, etc. | |
| - [write_plan](https://huggingface.co/aiflows/InteractivePlanGenFlowModule): Generates plan (user edit is allowed) and fetches user feedback. | |
| How it works: | |
| Controller calls write_plan until user is satisfied in the feedback, finish. | |
| <a id="run_planwriter"></a> | |
| # run\_planwriter | |
| <a id="PlanWriterAskUserFlow"></a> | |
| # PlanWriterAskUserFlow | |
| <a id="PlanWriterAskUserFlow.PlanWriterAskUserFlow"></a> | |
| ## PlanWriterAskUserFlow Objects | |
| ```python | |
| class PlanWriterAskUserFlow(HumanStandardInputFlow) | |
| ``` | |
| Refer to: https://huggingface.co/aiflows/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py | |
| This flow is used to ask the user a question and get a response. | |
| *Input Interface*: | |
| - `question` | |
| *Output Interface*: | |
| - `feedback` | |
| - `plan` | |
| *Configuration Parameters*: | |
| - `query_message_prompt_template`: The message template to prompt the user for input. | |
| - `request_multi_line_input_flag`: Whether to request multi-line input from the user. | |
| - `end_of_input_string`: The string to enter to indicate the end of input. | |
| <a id="PlanWriterAskUserFlow.PlanWriterAskUserFlow.run"></a> | |
| #### run | |
| ```python | |
| def run(input_data: Dict[str, Any]) -> Dict[str, Any] | |
| ``` | |
| Run the flow module. | |
| **Arguments**: | |
| - `input_data` (`Dict[str, Any]`): The input data to the flow module. | |
| **Returns**: | |
| `Dict[str, Any]`: The output data from the flow module. | |
| <a id="PlanWriterFlow"></a> | |
| # PlanWriterFlow | |
| <a id="PlanWriterFlow.PlanWriterFlow"></a> | |
| ## PlanWriterFlow Objects | |
| ```python | |
| class PlanWriterFlow(ContentWriterFlow) | |
| ``` | |
| This flow inherits from ContentWriterFlow. | |
| In the subflow of the executor, we specify the InteractivePlanGenFlow (https://huggingface.co/aiflows/InteractivePlanGenFlowModule) | |
| *Input Interface*: | |
| - `goal` | |
| *Output Interface*: | |
| - `plan` | |
| - `result` | |
| - `summary` | |
| - `status` | |
| *Configuration Parameters*: | |
| - Also refer to superclass ContentWriterFlow (https://huggingface.co/aiflows/ContentWriterFlowModule) | |
| - `input_interface`: the input interface of the flow | |
| - `output_interface`: the output interface of the flow | |
| - `subflows_config`: the configuration of the subflows | |
| - `early_exit_key`: the key in the flow state that indicates the early exit condition | |
| - `topology`: the topology of the flow | |
| <a id="PlanWriterFlow.PlanWriterFlow.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 subflow finishes running. | |
| configured in the topology of the subflow config. | |
| **Arguments**: | |
| - `output_payload` (`Dict[str, Any]`): the output payload of the subflow | |
| - `src_flow` (`Flow`): the subflow that generates the output payload | |
| **Returns**: | |
| `Dict[str, Any]`: the processed output payload | |
| <a id="PlanWriterFlow.PlanWriterFlow.run"></a> | |
| #### run | |
| ```python | |
| def run(input_data: Dict[str, Any]) -> Dict[str, Any] | |
| ``` | |
| This function runs the flow. | |
| **Arguments**: | |
| - `input_data` (`Dict[str, Any]`): the input data of the flow | |
| **Returns**: | |
| `Dict[str, Any]`: the output data of the flow | |
| <a id="__init__"></a> | |
| # \_\_init\_\_ | |
| <a id="PlanWriterCtrlFlow"></a> | |
| # PlanWriterCtrlFlow | |
| <a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow"></a> | |
| ## PlanWriterCtrlFlow Objects | |
| ```python | |
| class PlanWriterCtrlFlow(ChatAtomicFlow) | |
| ``` | |
| Refer to: https://huggingface.co/aiflows/JarvisFlowModule/blob/main/Controller_JarvisFlow.py | |
| This flow is a controller flow that controls the PlanWriterFlow. | |
| *Input Interface Non Initialized*: | |
| - `goal`: str | |
| *Input Interface Initialized*: | |
| - `feedback`: str | |
| - `goal`: str | |
| - `plan`: str | |
| *Output Interface*: | |
| - `command`: str | |
| - `command_args`: Dict[str, Any] | |
| *Configuration Parameters*: | |
| - `input_interface_non_initialized`: List[str] = ["goal"] | |
| - `input_interface_initialized`: List[str] = ["feedback", "goal", "plan"] | |
| - `output_interface`: List[str] = ["command", "command_args"] | |
| - `backend`: Dict[str, Any] : backend of the LLM | |
| - `commands`: List[Dict[str, Any]] : commands that the LLM can execute | |
| - `system_message_prompt_template`: str : the template of the system message prompt | |
| - `init_human_message_prompt_template`: str : the template of the initial human message prompt | |
| - `human_message_prompt_template`: str : the template of the human message prompt | |
| - `previous_messages`: Dict[str, Any] : the previous messages of the conversation (sliding window) | |
| <a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.__init__"></a> | |
| #### \_\_init\_\_ | |
| ```python | |
| def __init__(commands: List[Command], **kwargs) | |
| ``` | |
| This function initializes the flow. | |
| **Arguments**: | |
| - `commands` (`List[Command]`): List[Command] : commands that the LLM can execute | |
| - `kwargs` (`Dict[str, Any]`): other parameters | |
| <a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.instantiate_from_config"></a> | |
| #### instantiate\_from\_config | |
| ```python | |
| @classmethod | |
| def instantiate_from_config(cls, config) | |
| ``` | |
| This function instantiates the flow from the config. | |
| **Arguments**: | |
| - `config` (`Dict[str, Any]`): the config of the flow | |
| **Returns**: | |
| `ChatAtomicFlow`: the instantiated flow | |
| <a id="PlanWriterCtrlFlow.PlanWriterCtrlFlow.run"></a> | |
| #### run | |
| ```python | |
| def run(input_data: Dict[str, Any]) -> Dict[str, Any] | |
| ``` | |
| This function runs the flow. | |
| **Arguments**: | |
| - `input_data` (`Dict[str, Any]`): the input data | |
| **Returns**: | |
| `Dict[str, Any]`: the output of the flow | |