BasicPrompter (Abstract Base Class)
├── HostAgentPrompter
├── AppAgentPrompter
├── EvaluationAgentPrompter
├── ExperiencePrompter
├── DemonstrationPrompter
└── customized/
    └── LinuxAgentPrompter (extends AppAgentPrompter)

[
    {"type": "text", "text": "Current Screenshots:"},
    {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
]

def __init__(self, is_visual: bool, prompt_template: str, example_prompt_template: str):
    self.is_visual = is_visual
    self.prompt_template = self.load_prompt_template(prompt_template, is_visual)
    self.example_prompt_template = self.load_prompt_template(example_prompt_template, is_visual)

def system_prompt_construction(self) -> str:
    apis = self.api_prompt_helper(verbose=0)
    examples = self.examples_prompt_helper()
    third_party_instructions = self.third_party_agent_instruction()

    system_key = "system" if self.is_visual else "system_nonvisual"

    return self.prompt_template[system_key].format(
        apis=apis,
        examples=examples,
        third_party_instructions=third_party_instructions,
    )

def user_prompt_construction(
    self,
    control_item: List[str],      # Available applications/windows
    prev_subtask: List[Dict],      # Previous subtask history
    prev_plan: List[str],          # Previous plan steps
    user_request: str,             # Original user request
    retrieved_docs: str = "",      # Retrieved knowledge
) -> str

def user_prompt_construction(
    self,
    control_item: List[str],       # Available UI controls
    prev_subtask: List[Dict],      # Previous subtask history
    prev_plan: List[str],          # Previous plan steps
    user_request: str,             # Original user request
    subtask: str,                  # Current subtask
    current_application: str,      # Current app name
    host_message: List[str],       # Messages from HostAgent
    retrieved_docs: str = "",      # Retrieved knowledge
    last_success_actions: List = [],  # Last successful actions
) -> str

def user_content_construction(self, image_list: List[str], ...) -> List[Dict]:
    user_content = []

    if self.is_visual:
        # Add screenshots
        for i, image in enumerate(image_list):
            user_content.append({"type": "text", "text": f"Screenshot {i+1}:"})
            user_content.append({"type": "image_url", "image_url": {"url": image}})

    # Add text prompt
    user_content.append({
        "type": "text",
        "text": self.user_prompt_construction(...)
    })

    return user_content

@staticmethod
def prompt_construction(system_prompt: str, user_content: List[Dict]) -> List:
    return [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_content}
    ]

def api_prompt_helper(self, verbose: int = 1) -> str:
    """Construct formatted API documentation."""
    return self.api_prompt_template

Tool name: click_input
Description: Click on a control item

Parameters:
- id (string, required): The ID of the control item
- button (string, optional): Mouse button to click. Default: left
- double (boolean, optional): Whether to double-click. Default: false

Returns: Result of the click action

Example usage:
click_input(id="42", button="left", double=false)

def examples_prompt_helper(
    self, 
    header: str = "## Response Examples",
    separator: str = "Example",
    additional_examples: List[str] = []
) -> str:
    """Construct examples from YAML template."""
    template = """
    [User Request]:
        {request}
    [Response]:
        {response}"""

    example_list = []
    for key, values in self.example_prompt_template.items():
        if key.startswith("example"):
            example = template.format(
                request=values.get("Request"),
                response=json.dumps(values.get("Response"))
            )
            example_list.append(example)

    return self.retrieved_documents_prompt_helper(header, separator, example_list)

@staticmethod
def retrieved_documents_prompt_helper(
    header: str,      # Section header
    separator: str,   # Document separator
    documents: List[str]  # Retrieved documents
) -> str:
    """Format retrieved documents for the prompt."""
    if header:
        prompt = f"\n<{header}:>\n"
    else:
        prompt = ""

    for i, document in enumerate(documents):
        if separator:
            prompt += f"[{separator} {i+1}:]\n"
        prompt += document + "\n\n"

    return prompt

<Retrieved Documentation:>
[Document 1:]
To create a new email in Outlook, click the "New Email" button...

[Document 2:]
The email composition window has three main fields: To, Subject, and Body...

def blackboard_to_prompt(self) -> str:
    """Convert Blackboard state to prompt text."""
    # Implementation depends on specific agent needs
    pass

def third_party_agent_instruction(self) -> str:
    """Generate instructions for enabled third-party agents."""
    enabled_agents = config.system.enabled_third_party_agents
    instructions = []

    for agent_name in enabled_agents:
        config = get_third_party_config(agent_name)
        instructions.append(f"{agent_name}: {config['INTRODUCTION']}")

    return "\n".join(instructions)

def system_prompt_construction(self, additional_examples: List[str] = []) -> str:
    apis = self.api_prompt_helper(verbose=1)
    examples = self.examples_prompt_helper(additional_examples=additional_examples)

    # Select template based on configuration
    if config.system.action_sequence:
        system_key = "system_as"
    else:
        system_key = "system"

    if not self.is_visual:
        system_key += "_nonvisual"

    return self.prompt_template[system_key].format(apis=apis, examples=examples)

# config/ufo/system.yaml
# Prompt template paths
HOSTAGENT_PROMPT: "./ufo/prompts/share/base/host_agent.yaml"
APPAGENT_PROMPT: "./ufo/prompts/share/base/app_agent.yaml"
EVALUATION_PROMPT: "./ufo/prompts/evaluation/evaluate.yaml"

# Example prompt paths (visual vs. non-visual)
HOSTAGENT_EXAMPLE_PROMPT: "./ufo/prompts/examples/{mode}/host_agent_example.yaml"
APPAGENT_EXAMPLE_PROMPT: "./ufo/prompts/examples/{mode}/app_agent_example.yaml"

# Feature flags
ACTION_SEQUENCE: False  # Enable multi-action mode for AppAgent

from ufo.prompter.agent_prompter import AppAgentPrompter

class CustomAppPrompter(AppAgentPrompter):
    """Custom prompter for specialized application."""

    def system_prompt_construction(self, **kwargs) -> str:
        # Add custom logic
        base_prompt = super().system_prompt_construction(**kwargs)
        custom_instructions = self.load_custom_instructions()
        return base_prompt + "\n" + custom_instructions

    def load_custom_instructions(self) -> str:
        """Load application-specific instructions."""
        return "Custom instructions for specialized app..."

ufo/prompter/
├── basic.py                    # BasicPrompter abstract base class
├── agent_prompter.py           # HostAgentPrompter, AppAgentPrompter
├── eva_prompter.py             # EvaluationAgentPrompter
├── experience_prompter.py      # ExperiencePrompter
├── demonstration_prompter.py   # DemonstrationPrompter
└── customized/
    └── linux_agent_prompter.py # LinuxAgentPrompter (custom)