Skip to main content
Glama

app_drive_dialogs

Drive UI dialogs reactively by reading and classifying each screen, pressing the right button or stopping for human input. Dry-run previews decisions before allowing confirmation or commit presses.

Instructions

Answer dialogs reactively until none is left.

The reactive driver, which existed but was reachable only through the one wizard tool that used it. It reads whatever is on screen, classifies it, decides a press from that, and repeats. There is no scripted sequence, so a dialog appearing in a different order, or not at all, is handled rather than breaking a plan.

IT STOPS RATHER THAN GUESSING on a dialog it cannot classify, and on anything that needs a human. dry_run is the DEFAULT: it reports every decision and presses nothing, which is how to see what a sequence would do before letting it.

THE TWO GATES ARE SEPARATE ON PURPOSE. allow_confirm answers a yes/no question that moves an operation along; allow_commit permits the press that changes the design. Named for their consequences, because a caller reaching for one rarely means the other.

Args: intent: "proceed" to carry the operation forward, or "cancel" to back out of whatever is open. allow_commit: permit the design-changing press. allow_confirm: permit answering a confirmation. dry_run: decide and report, press nothing. Default True. wait_first: seconds to wait for the first dialog, since a caller fires a command and then drives. budget: seconds before giving up on a wedged editor.

Returns: Every observation and decision, plus committed, stopped_for_a_human and why it finished.

Input Schema

NameRequiredDescriptionDefault
budgetNo
intentNoproceed
dry_runNo
wait_firstNo
allow_commitNo
allow_confirmNo

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.6.1

TDQS

A3.9/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does it well: it discloses that it stops rather than guesses, that dry_run defaults to True, that the two gates are independent and named for their consequences, and that it stops for a human. It does not describe what state a stopped run leaves the editor in or any permission requirements, which keeps it short of a 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The operative information is front-loaded and the Args/Returns block is well organized, but the prose leans rhetorical ('IT STOPS RATHER THAN GUESSING', 'THE TWO GATES ARE SEPARATE ON PURPOSE') and the aside about existing only through one wizard tool is historical noise an agent does not need to decide.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists so return values needn't be explained, and the description still summarizes the key result fields (committed, stopped_for_a_human). For a six-parameter reactive driver with no annotations, the stop conditions, defaults, and gate semantics cover what an agent needs to call it safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% but the Args section documents all six parameters with meaning beyond the names: intent's two accepted values, the distinct consequences of allow_commit vs allow_confirm, dry_run's default and effect, and the units/role of wait_first and budget.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening line states the action precisely — reactively answer dialogs until none remain — and the body explains the read/classify/press loop, which is unambiguous. It does not distinguish itself from single-step siblings such as app_press_dialog_button or app_list_open_dialogs, leaving the agent to infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied (this is the loop that drives a sequence of dialogs after firing a command), and the dry_run paragraph gives a clear 'try this first' recommendation. However, no sibling tool is named as an alternative for one-shot presses or read-only inspection, and there is no explicit when-not-to-use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools