def execute(self) -> str:
    """
    Execute the flow and return the copied template path.
    :return: The path to the copied template file.
    """

    start_time = time.time()
    try:
        template_copied_path = self._choose_template_and_copy()
    except Exception as e:
        raise e
    finally:
        self.execution_time = round(time.time() - start_time, 3)
    return template_copied_path

def execute(
    self, template_copied_path: str, original_task: str, refined_steps: List[str]
) -> Dict[str, Any]:
    """
    Start the execution by retrieving the instantiated result.
    :param template_copied_path: The path of the copied template to use.
    :param original_task: The original task to refine.
    :param refined_steps: The steps to guide the refinement process.
    :return: The refined task and corresponding action plans.
    """

    start_time = time.time()
    try:
        instantiated_request, instantiated_plan = self._instantiate_task(
            template_copied_path, original_task, refined_steps
        )
    except Exception as e:
        raise e
    finally:
        self.execution_time = round(time.time() - start_time, 3)

    return  {
        "instantiated_request": instantiated_request,
        "instantiated_plan": instantiated_plan,
    }   

def get_prompter(self, is_visual: bool, main_prompt: str, example_prompt: str, api_prompt: str) -> str:
    """
    Get the prompt for the agent.
    This is the abstract method from BasicAgent that needs to be implemented.
    :param is_visual: The flag indicating whether the agent is visual or not.
    :param main_prompt: The main prompt.
    :param example_prompt: The example prompt.
    :param api_prompt: The API prompt.
    :return: The prompt string.
    """

    return PrefillPrompter(is_visual, main_prompt, example_prompt, api_prompt)

def message_constructor(
    self,
    dynamic_examples: str,
    given_task: str,
    reference_steps: List[str],
    doc_control_state: Dict[str, str],
    log_path: str,
) -> List[str]:
    """
    Construct the prompt message for the PrefillAgent.
    :param dynamic_examples: The dynamic examples retrieved from the self-demonstration and human demonstration.
    :param given_task: The given task.
    :param reference_steps: The reference steps.
    :param doc_control_state: The document control state.
    :param log_path: The path of the log.
    :return: The prompt message.
    """

    prefill_agent_prompt_system_message = self.prompter.system_prompt_construction(
        dynamic_examples
    )
    prefill_agent_prompt_user_message = self.prompter.user_content_construction(
        given_task, reference_steps, doc_control_state, log_path
    )
    appagent_prompt_message = self.prompter.prompt_construction(
        prefill_agent_prompt_system_message,
        prefill_agent_prompt_user_message,
    )

    return appagent_prompt_message

def process_comfirmation(self) -> None:
    """
    Confirm the process.
    This is the abstract method from BasicAgent that needs to be implemented.
    """

    pass

def execute(self, instantiated_request: str) -> Dict[str, Any]:
    """
    Execute the filter flow: Filter the task and save the result.
    :param instantiated_request: Request object to be filtered.
    :return: Tuple containing task quality flag, comment, and task type.
    """

    start_time = time.time()
    try:
        judge, thought, request_type = self._get_filtered_result(
            instantiated_request
        )
    except Exception as e:
        raise e
    finally:
        self.execution_time = round(time.time() - start_time, 3)
    return {
        "judge": judge,
        "thought": thought,
        "request_type": request_type,
    }

def get_prompter(
    self,
    is_visual: bool,
    main_prompt: str,
    example_prompt: str,
    api_prompt: str
) -> FilterPrompter:
    """
    Get the prompt for the agent.
    :param is_visual: The flag indicating whether the agent is visual or not.
    :param main_prompt: The main prompt.
    :param example_prompt: The example prompt.
    :param api_prompt: The API prompt.
    :return: The prompt string.
    """

    return FilterPrompter(is_visual, main_prompt, example_prompt, api_prompt)

def message_constructor(self, request: str, app: str) -> List[str]:
    """
    Construct the prompt message for the FilterAgent.
    :param request: The request sentence.
    :param app: The name of the operated app.
    :return: The prompt message.
    """

    filter_agent_prompt_system_message = self.prompter.system_prompt_construction(
        app=app
    )
    filter_agent_prompt_user_message = self.prompter.user_content_construction(
        request
    )
    filter_agent_prompt_message = self.prompter.prompt_construction(
        filter_agent_prompt_system_message, filter_agent_prompt_user_message
    )

    return filter_agent_prompt_message

def process_comfirmation(self) -> None:
    """
    Confirm the process.
    This is the abstract method from BasicAgent that needs to be implemented.
    """

    pass