Plugin de automatización de pruebas para Tauri multiplataforma mediante MCP (Model Context Protocol).
Permite que asistentes de IA como Claude interactúen con tu aplicación de escritorio Tauri para pruebas y automatización.
Este repositorio también funciona como un plugin de Claude Code. Tres pasos para una configuración completamente funcional:
1. Añade el marketplace e instala el plugin
/plugin marketplace add DaveDev42/tauri-plugin-mcp
/plugin install tauri-mcpDurante la instalación se te solicitará:
Directorio de la aplicación Tauri: ruta relativa a la raíz del proyecto (ej. . para repositorios de una sola aplicación, apps/desktop para monorepos).
2. Ejecuta el comando de instalación
/tauri-mcp:installEsto edita automáticamente tu proyecto Tauri: Cargo.toml, src-tauri/src/lib.rs, capacidades, package.json, la entrada del frontend (main.tsx/main.ts) y .gitignore. Cada escritura se previsualiza como un diff y requiere tu confirmación primero.
3. Reinicia Claude Code
El servidor MCP tauri-mcp se registra al reiniciar. Verifica con /mcp: debería mostrar tauri-mcp como conectado. Ahora puedes llamar a start_session, snapshot, click, etc.
Los servidores MCP se registran al iniciar Claude Code. Instalar el plugin o cambiar tauri_app_dir requiere un reinicio para que surta efecto.
El servidor MCP se entrega como un paquete de un solo archivo autocontenido (packages/tauri-mcp/dist/index.js) con todas las dependencias integradas; no se necesita node_modules en la máquina de destino, por lo que la instalación funciona de forma idéntica en macOS, Linux y Windows.
Qué incluye:
Componente | Descripción |
Servidor MCP | Paquete autocontenido |
Comando | Instalador de un solo uso que edita tu proyecto Tauri para conectar el plugin |
Skill | Orquestación de QA: prepara escenarios de prueba, delega al agente de QA, valida resultados |
Skill | Árboles de decisión de diagnóstico para problemas comunes de sesión MCP |
Agente | Agente de pruebas (haiku) que ejecuta escenarios de prueba usando herramientas MCP |
Hook de validación QA | Verifica que los resultados PASS de QA incluyan evidencia real de llamadas a herramientas |
Related MCP server: MCP Server Tauri
Multiplataforma: Windows (Named Pipes) + macOS/Linux (Unix Sockets)
Sin dependencia de CDP: Funciona en todos los backends de WebView, incluido macOS WKWebView
Integración MCP: Integración directa con Claude Code y otros clientes MCP
Soporte multiventana: Apunta a cualquier ventana por etiqueta; inyección automática de puente
Registro unificado: Registros de compilación, tiempo de ejecución, consola y red con filtrado
Asignación dinámica de puertos: Asignación automática de puertos aleatorios para evitar conflictos
Node.js >= 18
Tauri v2.x
pnpm (recomendado) o npm
Rust con cargo
[ ] Añadir plugin de Rust a src-tauri/Cargo.toml
[ ] Instalar paquete npm: pnpm add github:DaveDev42/tauri-plugin-mcp#main
[ ] Registrar plugin en src-tauri/src/lib.rs
[ ] Añadir permiso mcp:default
[ ] Inicializar puente en main.tsx
[ ] Crear .mcp.json para Claude Code
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp" }pnpm add github:DaveDev42/tauri-plugin-mcp#mainEl binario del servidor MCP (tauri-mcp) está disponible automáticamente después de la instalación. No se requiere configuración adicional.
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_mcp::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}Opción A: En tauri.conf.json o config/*.json5 (recomendado)
{
"security": {
"capabilities": [{
"identifier": "main-capability",
"windows": ["main"],
"permissions": ["core:default", "mcp:default"]
}]
}
}Opción B: Archivo separado (src-tauri/capabilities/default.json)
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"windows": ["main"],
"permissions": ["core:default", "mcp:default"]
}// Initialize MCP bridge for E2E testing (dev mode only)
if (import.meta.env.DEV) {
import('tauri-plugin-mcp').then(({ initMcpBridge }) => {
initMcpBridge().catch(err => {
console.warn('[MCP] Bridge initialization failed:', err);
});
});
}La configuración básica anterior incluye MCP en todas las compilaciones. Para aplicaciones de producción, probablemente quieras MCP solo en desarrollo y eliminado por completo de los binarios de lanzamiento.
Este enfoque utiliza la función de dependencia opcional de Cargo para que el plugin solo se compile cuando se solicite explícitamente.
[features]
default = []
dev-tools = ["dep:tauri-plugin-mcp"]
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp", optional = true }pub fn run() {
let mut builder = tauri::Builder::default();
#[cfg(feature = "dev-tools")]
{
builder = builder.plugin(tauri_plugin_mcp::init());
}
builder
.run(tauri::generate_context!())
.expect("error while running tauri application");
}Separa mcp:default en su propio archivo de capacidad para que pueda activarse/desactivarse en tiempo de compilación.
capabilities/default.json — siempre activo, sin permiso MCP:
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"windows": ["main"],
"permissions": ["core:default"]
}capabilities/.dev-tools.json.disabled — plantilla de permiso MCP (rastreada por git):
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "dev-tools",
"windows": ["main"],
"permissions": ["mcp:default"]
}capabilities/dev-tools.json — añadir a .gitignore (generado en tiempo de compilación):
# Dev-tools capability (generated from .disabled at build time)
src-tauri/capabilities/dev-tools.jsonbuild.rs copia la plantilla en su lugar cuando la función está habilitada, y la elimina en caso contrario:
fn main() {
let dev_tools_cap = std::path::Path::new("capabilities/dev-tools.json");
let source_path = std::path::Path::new("capabilities/.dev-tools.json.disabled");
if std::env::var("CARGO_FEATURE_DEV_TOOLS").is_ok() {
// Copy .disabled → active (skip if already identical to avoid rebuild churn)
let should_copy = if dev_tools_cap.exists() {
std::fs::read(source_path).ok() != std::fs::read(dev_tools_cap).ok()
} else {
true
};
if should_copy {
std::fs::copy(source_path, dev_tools_cap)
.expect("Failed to copy dev-tools capability file");
}
} else if dev_tools_cap.exists() {
std::fs::remove_file(dev_tools_cap).ok();
}
tauri_build::try_build(
tauri_build::Attributes::default()
).expect("Failed to build tauri");
}{
"scripts": {
"dev": "tauri dev --features dev-tools"
}
}Ahora pnpm dev habilita MCP, mientras que tauri build (sin la función) produce un lanzamiento limpio sin código MCP.
Nota: El protector del puente frontend (
import.meta.env.DEV) de la configuración básica sigue aplicándose: evita que el puente se inicialice incluso si el plugin estuviera presente en tiempo de ejecución.
Nota: Si instalaste el Plugin de Claude Code, el servidor MCP ya está configurado automáticamente. El plugin solicita el directorio de la aplicación Tauri durante la instalación. Esta sección es para configuración manual sin el plugin.
Añade a .mcp.json en la raíz de tu proyecto:
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "."
}
}
}
}Nota: Los usuarios de pnpm también pueden usar
pnpx tauri-mcpopnpm exec tauri-mcp.
Si la aplicación Tauri está en un subdirectorio (ej. apps/desktop), establece TAURI_APP_DIR:
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "./apps/desktop"
}
}
}
}Para monorepos con múltiples aplicaciones Tauri, ejecuta una instancia de servidor MCP separada por aplicación:
{
"mcpServers": {
"tauri-desktop": {
"command": "npx",
"args": ["tauri-mcp"],
"env": { "TAURI_APP_DIR": "./apps/desktop" }
},
"tauri-kiosk": {
"command": "npx",
"args": ["tauri-mcp"],
"env": { "TAURI_APP_DIR": "./apps/kiosk" }
}
}
}Las herramientas tienen nombres de espacio por nombre de servidor: mcp__tauri-desktop__snapshot, mcp__tauri-kiosk__snapshot, etc.
Herramienta | Parámetros | Descripción |
|
| Comprobar estado de la sesión (app); con |
|
| Iniciar sesión (lanzar app Tauri mediante |
| - | Detener sesión (matar árbol de procesos de la app) |
Herramienta | Parámetros | Descripción |
| - | Listar todas las ventanas abiertas con etiquetas, títulos, estado de foco y estado del puente |
|
| Enfocar una ventana específica por etiqueta |
Todas las herramientas de interacción aceptan un parámetro opcional window para apuntar a una ventana específica (por defecto es la ventana enfocada).
Herramienta | Parámetros | Descripción |
|
| Obtener árbol de accesibilidad con números de referencia para |
|
| Hacer clic en elemento por referencia o selector CSS |
|
| Rellenar campo de entrada |
|
| Presionar tecla del teclado (ej. "Enter", "Tab") |
|
| Navegar a URL |
|
| Tomar captura de pantalla mediante captura nativa del SO |
|
| Ejecutar JavaScript en webview |
Herramienta | Parámetros | Descripción |
|
| Acceso unificado a registros (compilación, tiempo de ejecución, consola, red) con filtrado por fuente/nivel |
|
| Obtener eventos recientes de reinicio/recarga de la app con archivos desencadenantes |
featuresPara lanzar con características de Cargo:
start_session({ features: ["my_feature"] })Esto ejecuta: pnpm tauri dev --features my_feature
Flujo de trabajo de prueba típico:
1. start_session({ timeout_secs: 120 })
2. snapshot() # Get element refs
3. click({ ref: 5 }) # Click button by ref
4. fill({ selector: "input[name='email']", value: "test@example.com" })
5. screenshot() # Verify result
6. stop_session()Claude Code <-> MCP Server <-> Socket <-> Tauri Plugin <-> JS Bridge <-> Your AppPlugin de Rust crea servidor IPC (socket Unix o tubería con nombre de Windows)
Servidor MCP se conecta a IPC y expone herramientas a Claude
Puente JS (initMcpBridge()) habilita operaciones DOM en WebView
Unix: {project_root}/.tauri-mcp.sock
Windows: \\.\pipe\tauri-mcp-{hash} (hash derivado de la ruta del proyecto)
El puente JS no se está ejecutando. Comprueba:
initMcpBridge() se llama en tu código frontend
La aplicación se está ejecutando en modo desarrollo (import.meta.env.DEV)
Comprueba la consola del navegador para errores de inicialización
Asegúrate de que la aplicación se esté ejecutando (primero start_session)
En Windows, comprueba la ruta de la tubería en los registros: [tauri-plugin-mcp] full_path: \\.\pipe\tauri-mcp-XXXXX
En Unix, comprueba si .tauri-mcp.sock existe en la raíz del proyecto
Aumenta timeout_secs (por defecto: 60)
Comprueba si pnpm tauri dev funciona manualmente
Busca errores de compilación en la salida de la terminal
Espera a que la aplicación cargue completamente (usa wait_for_ready: true)
Comprueba si el puente se inicializó (busca registros [MCP] en la consola)
Después de clonar, pnpm install configura automáticamente los hooks de git y compila el proyecto.
Los directorios dist/ se confirman en el repositorio para que las instalaciones basadas en git (pnpm add github:...) funcionen sin un paso de compilación. Un hook de pre-commit verifica que dist/ se mantenga sincronizado con las fuentes de TypeScript; si el hook bloquea tu commit, ejecuta:
pnpm build
git add packages/*/dist/Luego vuelve a intentar tu commit.
MIT OR Apache-2.0
Click element by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fails to disclose behavioral traits such as whether the click waits for element visibility, triggers navigation, or handles errors. It adds no behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the action, but it is overly minimal. It sacrifices completeness for brevity, lacking sufficient detail for a three-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description does not provide enough contextual completeness. It omits behavioral details, expected side effects, and error handling, which are important for correct tool usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all parameters. The description adds no extra semantics beyond the schema's details, achieving baseline adequacy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'click' and the resource 'element', and specifies two methods of identification (ref or selector). It effectively distinguishes from sibling tools like fill or press_key, but could be more explicit about simulating a mouse click.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as press_key or evaluate_script. There is no mention of prerequisites, context, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run JS in webview
| Name | Required | Description | Default |
|---|---|---|---|
| script | Yes | JS code | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'Run JS' without indicating if the script is sandboxed, whether it returns results, or any potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the key action. It is efficient but could benefit from additional context without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a script execution tool with two parameters and no output schema, the description is incomplete. It does not explain return values, error behavior, or how the script interacts with the webview environment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds no value beyond the schema: 'JS code' and 'Window label' are already in the input schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Run JS in webview' clearly states the action and target resource. It distinguishes from sibling browser tools like click and navigate by specifying script execution, but lacks detail on what 'webview' refers to.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as click or fill. There is no mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill input by ref or selector
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Ref from snapshot | |
| selector | No | CSS selector | |
| value | Yes | Value | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as whether it clears the existing value, supports file inputs, or handles non-input elements. The brief description leaves significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (5 words) and front-loaded. However, it may be too brief, sacrificing necessary detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and lack of output schema, the description is incomplete: it does not specify the behavior on different input types, whether it simulates typing or sets value programmatically, or error scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all 4 parameters. The description adds 'by ref or selector' to clarify parameter usage, but does not add further semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'fill' and resource 'input', and specifies the method 'by ref or selector'. It is clear but does not differentiate from siblings like 'click' or 'press_key'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., 'press_key' for key presses, 'click' for clicks). No context or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Focus a specific window by label
| Name | Required | Description | Default |
|---|---|---|---|
| window | Yes | Window label to focus |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It fails to disclose what 'focus' entails (e.g., bring to front, activate window) or behavior on missing label.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff, front-loaded. Score would be 5 if it contained more behavioral detail without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, and description lacks detail on return values, error cases, or prerequisites. Minimal for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear parameter description. Tool description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'focus', the resource 'window', and the qualifier 'by label'. It distinguishes the tool from siblings like 'list_windows' and 'click'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no preconditions or exclusions provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get application logs with filtering. Filters can be combined (e.g., ["build", "error"] for build errors only).
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Filters to apply (empty = all logs) | |
| limit | No | Max entries | |
| clear | No | Clear logs after reading | |
| window | No | Window label for frontend logs (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behavioral traits. It mentions filter combination but omits the clear parameter's destructive nature and window parameter's scope. Key behaviors remain undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: one sentence plus a helpful example. No wasted words, but could be better structured (e.g., bullet points). Still effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 4 parameters and no output schema, the description only covers filter semantics. It does not explain the return format, window parameter, clear effect, or limitations. Incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3). The tool description adds an example for filter combination, clarifying that filters can be combined, though the case of a string type with array-like example may cause confusion. Minimal value added beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get application logs' as the verb+resource, and adds filtering details. However, it could be more specific about the log source (e.g., browser console logs) to fully distinguish from sibling tools like get_restart_events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives (e.g., evaluate_script, screenshot). The description only explains filtering, not the broader context of log retrieval use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent app restart/reload events with the files that triggered them. Includes Rust rebuilds (backend) and HMR updates (frontend).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max events | |
| clear | No | Clear events after reading | |
| window | No | Window label for frontend HMR events (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It partially discloses what events are included but fails to mention the destructive nature of the 'clear' parameter or side effects. The description is neutral but could be more explicit about read-only vs modifying behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and scope, no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return values. It mentions events include files but not the structure. Also missing context on parameter interactions (e.g., clear, window) beyond schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds context about event types but does not enhance parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves app restart/reload events, specifies it includes Rust rebuilds and HMR updates, and uses a specific verb 'Get' with a resource, distinguishing it from siblings like get_logs or get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs alternatives (e.g., get_logs), nor does it mention when not to use it or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check session (app) status. Use probe_bridge to verify bridge health per window.
| Name | Required | Description | Default |
|---|---|---|---|
| probe_bridge | No | Actively probe bridge health per window (adds latency) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only mentions that probe_bridge adds latency, but does not disclose behavioral traits of this tool itself (e.g., read-only, latency, destructions). The description is too brief to offer adequate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise—two short sentences—with no unnecessary words. Every sentence serves a purpose: stating the tool's function and directing to an alternative for a specific use case.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and only one parameter, the description is minimally adequate. It states the purpose and references an alternative, but lacks details on return values, scope of 'session status', or how it fits with other tools. For a tool with 12 siblings, more completenss would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with one parameter described as 'Actively probe bridge health per window (adds latency)'. The description does not add extra meaning beyond the schema, so it meets the baseline 3 without exceeding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Check session (app) status' as a specific verb+resource. It further distinguishes from the sibling 'probe_bridge' by directing to use that tool for verifying bridge health per window, avoiding confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides limited guidance: it tells users to use 'probe_bridge' for bridge health verification, implying this tool is for general session status. However, it does not specify when to choose this over other siblings like get_logs or get_restart_events, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all open windows with their labels, titles, and focus state
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description accurately conveys a read-only operation with no side effects. It is straightforward but could mention if any special permissions or constraints apply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no extraneous information. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose and output fields (labels, titles, focus state). Missing details like ordering or whether minimized windows are included, but acceptable for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and the description correctly omits parameter details. According to guidelines, zero parameters baseline is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists open windows and specifies the information returned (labels, titles, focus state). It distinguishes from sibling tools like focus_window, which performs a different action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you need to see current windows) but does not explicitly state when to use or not use this tool, nor does it mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press key
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Key name | |
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description offers no behavioral information such as whether the press is momentary, if it supports key combinations, or what happens on failure. The agent is left to infer all side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While short, the description is under-specified. It does not earn its place as it adds no information beyond the tool name. It is not appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the two parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the tool's behavior, return value, or error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides for 'key' and 'window'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description 'Press key' is essentially a tautology of the tool name 'press_key'. It does not specify what kind of key press (e.g., single key, combination) or provide any distinguishing detail from sibling tools like 'click' or 'fill'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description does not mention typical scenarios (e.g., keyboard simulation) or exclude cases where 'click' or 'fill' might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take screenshot
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It only states the action without explaining output, side effects, or required permissions. 'Take screenshot' is too vague for an agent to understand the tool's full impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two words, with no wasted text. However, it may be too brief for optimal clarity, though it earns a high score for lack of verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema or annotations, and the presence of a potentially similar sibling (snapshot), the description is insufficiently complete. It omits return value, side effects, and how it differs from snapshot.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, so the description adds no extra meaning beyond what the schema already provides (window label). Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Take screenshot' clearly states the action and resource, but does not differentiate from the sibling tool 'snapshot', which may have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like snapshot, nor are there any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get accessibility tree (returns ref numbers for click/fill)
| Name | Required | Description | Default |
|---|---|---|---|
| window | No | Window label (default: focused window) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions the return value (ref numbers) and hints at read-only nature, but does not disclose error conditions, effects, or permissions. Without annotations, this is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core functionality without extraneous words. It is efficient and scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description adequately covers what it does and what it returns. It could mention preconditions or errors, but remains mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'window' is fully described in the input schema. The description adds no additional information about parameter usage or defaults, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Get accessibility tree' and its output 'returns ref numbers for click/fill', which distinguishes it from sibling tools like click and fill. It is specific about the resource and purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use before actions like click or fill, but does not explicitly state when to use it or provide alternatives. No comparison with siblings is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start session (launch Tauri app)
| Name | Required | Description | Default |
|---|---|---|---|
| wait_for_ready | No | Wait for ready | |
| timeout_secs | No | Timeout seconds | |
| features | No | Cargo features to enable | |
| devtools | No | Open devtools on launch |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'launch Tauri app', missing critical details like whether the call blocks until the app is ready, if it returns a session ID, or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words. The parenthetical adds clarity. Could be slightly more informative without losing conciseness, but it is not overly terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that launches an application, the description lacks information about return values, error states, expected duration, and side effects. No output schema, so description should cover these aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are documented. However, the tool description adds no meaning beyond the schema; for example, it doesn't explain how 'wait_for_ready' interacts with 'timeout_secs'. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Start') and the resource ('session'), and includes a parenthetical explanation ('launch Tauri app') that distinguishes it from siblings like 'stop_session' and 'get_session_status'. However, 'session' could be more specific about what kind of session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For instance, it doesn't explain whether it should be called before other tools, if there are prerequisites, or when 'stop_session' is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop session (kill app)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It only says 'kill app' but does not disclose whether state is saved, if confirmation is required, or any side effects. Minimal behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single efficient phrase with no unnecessary words. However, it could be slightly more descriptive without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is too minimal for a mutation tool. It lacks context on how the session termination affects the application state or subsequent actions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist and schema coverage is 100%, so the baseline is 3. The description adds no parameter info beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the action 'stop session' with the parenthetical '(kill app)' emphasizing termination. It directly contrasts with sibling tools like start_session and get_session_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives such as get_session_status or focus_window. Usage is implied by the name but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.3.6app_statusget_session_statuslaunch_appstart_sessionstop_appstop_sessionv0.1.0app_statusclickevaluate_scriptfillfocus_windowget_logsget_restart_eventslaunch_applist_windowsnavigatepress_keyscreenshotsnapshotstop_appScored across 14 tools
Each tool targets a distinct action or information source: UI interactions (click, fill, press_key), scripting (evaluate_script), navigation (navigate), visual capture (screenshot), accessibility (snapshot), window management (list_windows, focus_window), session lifecycle (start/stop_session), and diagnostics (get_logs, get_restart_events, get_session_status). No two tools have overlapping purposes.
All tool names follow a clear verb_noun pattern using lowercase with underscores (e.g., get_logs, focus_window, start_session). Even single-word names like click, fill, navigate are consistent with the imperative style. No mixed conventions or inconsistent verbs.
14 tools is well-scoped for a Tauri testing/MCP server. It covers all major aspects: session control, window management, UI interaction, scripting, diagnostics, and capture. The count is neither too sparse (missing essential features) nor bloated.
The tool surface covers the full lifecycle of a Tauri app test: start/stop sessions, manage windows, interact via clicks/keys/scripts, navigate, capture screenshots and accessibility trees, and retrieve logs/events. No obvious gaps for typical automation tasks, making it a self-contained toolset.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Run, debug, and triage tests from your IDE using natural language, no dashboard switching, no manual data transfers. The TestMu AI (formerly LambdaTest) MCP Server is a single remote server exposing four tool suites: HyperExecute — analyze your project, generate YAML configs and test runner commands, then monitor jobs and sessions. Automation — pull a TestID's details plus command, network, and console logs into one chat for instant root-cause analysis. Includes mobile app upload. SmartUI — explain pixel, layout, DOM, and perceptual changes in a visual regression run, with context-aware React/HTML/CSS fixes. Accessibility — audit any public URL or a local React app against WCAG and get ready-to-apply remediation steps. Connects over https://mcp.lambdatest.com/mcp using OAuth 2.1 — no API keys in your config. One-click install in Cursor; works with Claude, GitHub Copilot, Cline, and any MCP client. Tests execute on the TestMu AI cloud: 3,000+ browsers and 10,000+ real devices.
A Model Context Protocol server for Wix AI tools
Drive real devices from your AI Coding tool. Embed a client SDK (Unity, Godot, Flutter, iOS/macOS, Android, React Native, Web) in your app, then capture screenshots, traverse the UI tree, inject taps and key events, and run automated test tasks on the physical device over a secure relay.
