通过 MCP (Model Context Protocol) 实现的跨平台 Tauri 测试自动化插件。
使 Claude 等 AI 助手能够与您的 Tauri 桌面应用进行交互，以进行测试和自动化。
本仓库同时也是一个 Claude Code 插件。实现完整配置只需三步：
1. 添加市场并安装插件
/plugin marketplace add DaveDev42/tauri-plugin-mcp
/plugin install tauri-mcp安装过程中，系统会提示您输入：
Tauri 应用目录：相对于项目根目录的路径（例如，单应用仓库为 .，Monorepo 为 apps/desktop）。
2. 运行安装程序命令
/tauri-mcp:install此命令会自动编辑您的 Tauri 项目：Cargo.toml、src-tauri/src/lib.rs、capabilities、package.json、前端入口 (main.tsx/main.ts) 以及 .gitignore。每次写入都会先预览差异并要求您确认。
3. 重启 Claude Code
tauri-mcp MCP 服务器会在重启时注册。使用 /mcp 进行验证 — 它应该显示 tauri-mcp 已连接。现在您可以调用 start_session、snapshot、click 等命令。
MCP 服务器在 Claude Code 启动时注册。安装插件或更改 tauri_app_dir 都需要重启才能生效。
MCP 服务器以自包含的单文件包 (packages/tauri-mcp/dist/index.js) 形式发布，所有依赖项均已内联 — 目标机器上无需 node_modules，因此在 macOS、Linux 和 Windows 上的安装方式完全相同。
包含内容：
组件 | 描述 |
MCP 服务器 | 自包含的 |
| 一键式安装程序，用于编辑您的 Tauri 项目以连接插件 |
| QA 编排 — 准备测试场景、委派给 QA 代理、验证结果 |
| 针对常见 MCP 会话问题的诊断决策树 |
| 使用 MCP 工具执行测试场景的测试代理 (haiku) |
QA 验证钩子 | 验证 QA PASS 结果是否包含实际的工具调用证据 |
Related MCP server: MCP Server Tauri
跨平台：Windows (命名管道) + macOS/Linux (Unix 套接字)
无 CDP 依赖：适用于所有 WebView 后端，包括 macOS WKWebView
MCP 集成：与 Claude Code 及其他 MCP 客户端直接集成
多窗口支持：通过标签定位任何窗口；自动桥接注入
统一日志记录：包含过滤功能的构建、运行时、控制台和网络日志
动态端口分配：自动随机分配端口以避免冲突
Node.js >= 18
Tauri v2.x
pnpm (推荐) 或 npm
Rust (配合 cargo)
[ ] 将 Rust 插件添加到 src-tauri/Cargo.toml
[ ] 安装 npm 包：pnpm add github:DaveDev42/tauri-plugin-mcp#main
[ ] 在 src-tauri/src/lib.rs 中注册插件
[ ] 添加 mcp:default 权限
[ ] 在 main.tsx 中初始化桥接
[ ] 为 Claude Code 创建 .mcp.json
[dependencies]
tauri-plugin-mcp = { git = "https://github.com/DaveDev42/tauri-plugin-mcp" }pnpm add github:DaveDev42/tauri-plugin-mcp#mainMCP 服务器二进制文件 (tauri-mcp) 在安装后自动可用。无需额外设置。
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_mcp::init())
.run(tauri::generate_context!())
.expect("error while running tauri application");
}选项 A：在 tauri.conf.json 或 config/*.json5 中（推荐）
{
"security": {
"capabilities": [{
"identifier": "main-capability",
"windows": ["main"],
"permissions": ["core:default", "mcp:default"]
}]
}
}选项 B：单独的文件 (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);
});
});
}上述基本设置将 MCP 包含在所有构建中。对于生产环境应用，您可能希望 仅在开发阶段 使用 MCP，并将其从发布二进制文件中完全剥离。
此方法使用 Cargo 的可选依赖特性，以便仅在明确请求时才编译插件。
[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");
}将 mcp:default 分离到其自己的 capability 文件中，以便在构建时进行切换。
capabilities/default.json — 始终激活，无 MCP 权限：
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"windows": ["main"],
"permissions": ["core:default"]
}capabilities/.dev-tools.json.disabled — MCP 权限模板 (git 跟踪)：
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "dev-tools",
"windows": ["main"],
"permissions": ["mcp:default"]
}capabilities/dev-tools.json — 添加到 .gitignore (构建时生成)：
# Dev-tools capability (generated from .disabled at build time)
src-tauri/capabilities/dev-tools.json当启用该特性时，build.rs 会将模板复制到位，否则将其删除：
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"
}
}现在 pnpm dev 会启用 MCP，而 tauri build（不带该特性）会生成一个不包含任何 MCP 代码的干净发布版本。
注意： 基本设置 中的前端桥接守卫 (
import.meta.env.DEV) 仍然适用 — 即使插件在运行时以某种方式存在，它也能防止桥接初始化。
注意： 如果您安装了 Claude Code 插件，MCP 服务器已自动配置。插件会在安装过程中提示输入 Tauri 应用目录。本节适用于不使用插件的手动设置。
在项目根目录的 .mcp.json 中添加：
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "."
}
}
}
}注意： pnpm 用户也可以使用
pnpx tauri-mcp或pnpm exec tauri-mcp。
如果 Tauri 应用位于子目录中（例如 apps/desktop），请设置 TAURI_APP_DIR：
{
"mcpServers": {
"tauri-mcp": {
"command": "npx",
"args": ["tauri-mcp"],
"env": {
"TAURI_APP_DIR": "./apps/desktop"
}
}
}
}对于包含多个 Tauri 应用的 Monorepo，请为每个应用运行一个单独的 MCP 服务器实例：
{
"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" }
}
}
}工具按服务器名称命名空间：mcp__tauri-desktop__snapshot、mcp__tauri-kiosk__snapshot 等。
工具 | 参数 | 描述 |
|
| 检查会话（应用）状态；若 |
|
| 启动会话（通过 |
| - | 停止会话（终止应用进程树） |
工具 | 参数 | 描述 |
| - | 列出所有打开的窗口及其标签、标题、焦点状态和桥接状态 |
|
| 通过标签聚焦特定窗口 |
所有交互工具都接受一个可选的 window 参数以定位特定窗口（默认为当前焦点窗口）。
工具 | 参数 | 描述 |
|
| 获取带有 |
|
| 通过引用或 CSS 选择器点击元素 |
|
| 填充输入字段 |
|
| 按下键盘按键（例如 "Enter", "Tab"） |
|
| 导航到 URL |
|
| 通过原生 OS 捕获进行截图 |
|
| 在 webview 中执行 JavaScript |
工具 | 参数 | 描述 |
|
| 统一日志访问（构建、运行时、控制台、网络），支持源/级别过滤 |
|
| 获取最近的应用重启/重载事件及触发文件 |
features 参数要使用 Cargo 特性启动：
start_session({ features: ["my_feature"] })这会运行：pnpm tauri dev --features my_feature
典型的测试工作流：
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 AppRust 插件 创建 IPC 服务器（Unix 套接字或 Windows 命名管道）
MCP 服务器 连接到 IPC 并向 Claude 公开工具
JS 桥接 (initMcpBridge()) 在 WebView 中启用 DOM 操作
Unix: {project_root}/.tauri-mcp.sock
Windows: \.pipe auri-mcp-{hash} (哈希值由项目路径派生)
JS 桥接未运行。请检查：
前端代码中是否调用了 initMcpBridge()
应用是否在开发模式下运行 (import.meta.env.DEV)
检查浏览器控制台是否有初始化错误
确保应用正在运行（先执行 start_session）
在 Windows 上，检查日志中的管道路径：[tauri-plugin-mcp] full_path: \.pipe auri-mcp-XXXXX
在 Unix 上，检查项目根目录中是否存在 .tauri-mcp.sock
增加 timeout_secs（默认：60）
检查 pnpm tauri dev 是否能手动运行
查看终端输出中的构建错误
等待应用完全加载（使用 wait_for_ready: true）
检查桥接是否已初始化（查看控制台中的 [MCP] 日志）
克隆后，pnpm install 会自动配置 git 钩子并构建项目。
dist/ 目录已提交到仓库，以便基于 git 的安装 (pnpm add github:...) 无需构建步骤即可工作。预提交钩子会验证 dist/ 是否与 TypeScript 源码保持同步 — 如果钩子阻止了您的提交，请运行：
pnpm build
git add packages/*/dist/然后重试您的提交。
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.
