Controller_CoderFlow.yaml

_target_: flow_modules.aiflows.CoderFlowModule.Controller_CoderFlow.instantiate_from_default_config
name: "ControllerFlow_Coder"
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"
  - "code_library"

input_interface_initialized:
  - "goal"
  - "result"
  - "memory_files"
  - "plan"
  - "logs"
  - "code_library"

#######################################################
# Output keys
#######################################################

output_interface:
  - 'command'
  - 'command_args'

backend:
  api_infos: ???
  model_name:
    openai: gpt-4
    azure: azure/gpt-4

commands:
  extend_library:
    description: "Given goal, write functions to achieve the goal, and then extend the library with the functions"
    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" ]
  run_code:
    description: "Run a code script written by yourself, e.g. downloading a package to the current environment, importing and calling a function from the code library"
    input_args: [ "code", "language" ]


system_message_prompt_template:
  _target_: aiflows.prompt_template.JinjaPrompt
  template: |2-
          Your department is in charge of achieving goals with writing and executing code. You are the leader of this department.
    
          Here is the goal you need to achieve:
            {{goal}}
          
          You have a code library located at {{code_library_location}}, which contains functions that are already written and saved by your subordinates. 
          Here are the functions in the library:
            {{code_library}}
    
          You work with several subordinates, they will be in charge of the specific tasks, including extending the code library, running a code script (you need to write the code script yourself, e.g. importing and calling a function from the code library), 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 located in a plan file {{plan_file_location}}:
            {{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 asks to extend the library, call `extend_library` with the goal of the current step of plan.
          2. In one of the following situations, call `run_code` with the code script you write:
            2.1. The current step of plan does not require to extend the library, but requires to run a code script.
            2.2. The current step of plan requires to import and run some functions from the library. In this case you **MUST** make sure you import the library, something like `from LIBRARY_NAME import FUNCTION_NAME` should suffice.
            2.3. You need to download a package to the current environment, e.g. `pip install PACKAGE_NAME`, in this case the language of code should be `shell`.
          After the code is run, the user will provide feedback about the execution, react to the feedback accordingly.
          3. Whenever you have done one step of the plan, **it could be either extending the library or running the code**, do the following:
            3.1 Reflect on what plan you are having right now.
            3.2 Reflect on which step of the plan you just finished.
            3.3 Generate a plan, **it is exactly the same as the plan you have now, but with the current step of plan marked as done**
            3.4 Call `update_plan` with the plan you just generated.
          4. Proceed to the next step of the plan, go back to workflow 1 or 2.
          5. When every step of the plan is done, call the `finish` command, with a summary of what was done.

          **You MUST call `update_plan` whenever you realize one step of the plan, for example, extending the library or running the code is done.**
          
          Here is an example of execution:  
          ### Beginning of an example execution: ###
          Plan: 1. Extend the library with a function that reads the stock prices from yahoo finance for the last `k` months for a company given its `company_code`  2. Call this function for `company_code`=TSLA and `k`=6.
          You start from step 1 of the plan, execute workflow 1, the extend_library command is called with the goal of step 1 of the plan.
          You are informed of what functions are written and saved to the library.
          You realize that step 1 is done, you go to workflow 3 to update the plan:
              3.1 You recall the plan you have.
              3.2 You realize step 1 of the plan is done.
              3.3 You generate the updated plan: 1. Extend the library with a function that reads the stock prices for the last k months for a company given its `company_code` (DONE) 2. Call this function for `company_code`=TSLA and k=6.
              3.4 You call `update_plan` with the generated plan.
          The updated plan will override the existing plan, you are informed of the behaviour of override.
          You enter step 2 of the plan. 
          You go to workflow 2 to run a code script, you write a code script that imports the function you just wrote and call it with the arguments specified in the plan.
          You are informed that package yahoo finance is not installed, the user instructs to install the yahoo finance package, you go to workflow 2 to run a code script, you write a code script that installs the package.
          You are informed that the package is installed, you go to workflow 2 to run a code script, you write a code script that imports the function you just wrote and call it with the arguments specified in the plan.
          You are informed that the code has been successfully ran, the user is satisfied with the result.
          You realize that step 2 is done, you go to workflow 3 to update the plan:
              3.1 You recall the plan you have.
              3.2 You realize step 2 of the plan is done.
              3.3 You generate the updated plan: 1. Extend the library with a function that reads the stock prices for the last k months for a company given its `company_code` (DONE) 2. Call this function for `company_code`=TSLA and k=6. (DONE)
              3.4 You call `update_plan` with the generated plan.
          The updated plan will override the existing plan, you are informed of the behaviour of override.
          All steps are done, you call `finish`, with a summary of what functions are written and saved to the library.
          ### End of an example of execution ###
    
          Here is a list of history actions you have taken, for your reference:
            {{logs}}
    
          Constraints:
          1. Exclusively use the commands listed in double quotes e.g. "command name"
          
          Your response **MUST** be in the following format:
              Response Format:
              {
              "command": "call one of the subordinates",
              "command_args": {
                  "arg name": "value"
                  }
              }
          Ensure your responses can be parsed by Python json.loads

  input_variables: ["commands", "plan_file_location", "plan", "logs", "code_library_location", "code_library", "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