BrowserMesh is a local MCP server that lets AI clients control isolated Chromium browser sessions, with explicit session/page addressing, concurrency, and persistence.
Session & Page Management: Create, list, get, and close isolated browser sessions and pages within a session; optionally restore saved state when creating a session.
Navigation: Navigate to URLs, go back/forward, and reload pages.
Inspection: Get current URL and title, accessibility snapshots with password redaction, and visible text from elements using semantic or CSS locators.
Interaction: Click, double-click, fill, press keys, select options, hover, focus, check/uncheck, scroll, and drag-and-drop.
Screenshot: Capture in-memory PNG screenshots of the viewport, full page, or specific elements, returned as MCP image content.
State Persistence: Save, list, and remove browser state (cookies, storage, auth) under logical IDs; restore into new sessions.
Isolation & Concurrency: Each session has a fully isolated browser context; operations within a session are serialized deterministically, while different sessions run concurrently.
Explicit Addressing: All operations require explicit sessionId and pageId; no global current session or page.
Observability & Waits: Console, page errors, network, and failed request tools, plus deterministic waits and action-and-wait tools.
Safety & Reliability: Bounded timeouts, structured error handling, graceful shutdown, resource cleanup; no arbitrary JavaScript execution, no caller-controlled file paths, and no secrets exposed across the MCP boundary.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@BrowserMesh Test checkout as customer and verify order as admin simultaneously"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Run many browser sessions at once, fully isolated from each other, from one MCP server.
Every other browser MCP server gives your AI client one browser with a current tab. BrowserMesh gives it as many independent sessions as the task needs — each with its own cookies, storage, and authentication — running in parallel. Test checkout as a customer while an admin session verifies the order, in one conversation, without either seeing the other's state.
External AI client
|
MCP stdio
|
BrowserMesh runtime
| | |
Session A Session B Session C
Context A Context B Context CThe external client reasons and plans. BrowserMesh executes browser operations, enforces isolation, orders work within each session, and returns structured results.
Works with Claude Code, Claude Desktop, Codex, Cursor, Windsurf, Qwen, and any other MCP-compatible client.
Claude Code:
claude mcp add browsermesh -- npx -y browsermeshAny other client, in its MCP configuration file:
{
"mcpServers": {
"browsermesh": {
"command": "npx",
"args": ["-y", "browsermesh"]
}
}
}That is the whole setup. On its first start BrowserMesh downloads the Chromium build it uses, so
there is no separate install step. Pass --no-auto-install to manage the browser yourself, in
which case MCP discovery still works and browser_session_create returns an actionable
BROWSER_ERROR explaining what to run.
Then ask for the work in plain language:
Test the checkout flow as a buyer and confirm the order appeared, as an admin, at the same time.
The client creates one session per role on its own. BrowserMesh also publishes a parallel_roles
prompt that spells the workflow out, so a client can offer it directly.
Check an installation without starting the protocol:
npx -y browsermesh --doctorChromium and BrowserMesh remain on your machine. There is no hosted BrowserMesh service.
Renamed in 0.2. The npm package was
multi-agent-browser-mcpand is nowbrowsermesh, matching the name everything else already used. Changeargsto["-y", "browsermesh"]; nothing else moves.
Related MCP server: agentify-desktop
BrowserMesh v0.1 is intentionally small: one local Node.js process, one Chromium process, and one
non-persistent BrowserContext for every ready session.
It provides:
explicit session and page addressing;
isolated browser contexts and page ownership checks;
navigation, inspection, interaction, waits, capture, and persistence;
per-session serialization with parallel execution across independent sessions;
bounded timeouts, structured errors, graceful shutdown, and resource cleanup;
MCP stdio integration with deterministic integration and end-to-end tests.
BrowserMesh is a browser runtime, not an internal agent framework, LLM orchestrator, message bus, Playwright fork, browser GUI, or interactive shell.
Configure BrowserMesh once in an MCP-compatible AI client.
The client starts BrowserMesh over stdio and discovers its tools.
Describe the browser task in natural language.
The client creates the required sessions and chooses the tools to invoke.
BrowserMesh executes the operations and returns structured results.
Use a separate session for each user, account, role, authentication state, or independent parallel workflow. BrowserMesh tools are normally selected by the external client rather than called by hand.
BrowserMesh v0.1 targets Node.js 24 and supports Node.js 22 as its minimum supported major version.
Clone the repository and run:
npm install
npx playwright install chromium
npm run buildThen configure an MCP client to launch the locally built server:
{
"mcpServers": {
"browsermesh": {
"command": "node",
"args": ["/absolute/path/to/browsermesh/dist/cli.js"]
}
}
}For development:
npm run verify
npm run verify:packageThere is no global:
current session;
active session;
current page;
active page;
current tab.
Every browser operation explicitly identifies its session.
Every page-specific operation explicitly identifies its page.
Conceptually:
browser_session_create
│
▼
{
sessionId,
pageId
}
│
▼
browser_navigate({
sessionId,
pageId,
...
})A newly created session contains one deterministic initial page.
browser_session_create returns the initial pageId immediately so an AI client does not need an additional browser_page_list call before its first browser action.
The page also appears in browser_page_list and is marked isDefault.
Session views consistently expose sessionId; page views consistently expose pageId and their owning sessionId.
The isDefault marker is informational only. Browser operations still use explicit pageId addressing.
Each ready BrowserMesh session maps to its own non-persistent Chromium BrowserContext.
Therefore independent sessions must not accidentally share:
cookies;
browser storage/authentication state;
pages;
page references;
current URLs;
DOM snapshots;
screenshots;
form state.
A pageId belonging to one session cannot be used through another session.
Cross-session page addressing is rejected.
Every live session has an independent serial operation queue.
Operations targeting the same session execute deterministically in accepted order.
For example:
Session A
navigate
↓
snapshot
↓
click
↓
get_urlA read-style operation does not bypass an in-progress navigation or interaction.
A failed or timed-out operation must not poison the queue. Later accepted operations continue normally after the failed operation settles.
Each timeoutMs is one absolute budget starting when BrowserMesh accepts the operation. Time spent
waiting in the owning session queue and every later browser-adapter step consume that same budget;
no adapter step receives a renewed full timeout.
MCP request cancellation is propagated into BrowserMesh as an engine-independent operation signal.
A same-session request cancelled while queued is skipped before it can touch browser state. If a
Playwright action is already running and cannot be aborted safely, BrowserMesh keeps its queue slot
until the real action settles, so later work cannot overtake it. Passive waits detach their owned
abort listeners and timers promptly, and the session queue remains usable after cancellation. MCP
clients observe their SDK's cancellation error (typically an AbortError, or an MCP error carrying
that reason); a separate tool result after protocol cancellation is not guaranteed.
Different sessions do not share a global operation lock:
Session A ═════════════════════►
Session B ═════════════════════►
Session C ═════════════════════►This allows independent browser workflows to run concurrently.
When session close begins:
the session enters closing;
new operations targeting it are rejected;
operations already accepted into its queue are drained;
its pages and BrowserContext are closed;
live engine handles are removed;
the session becomes closed.
Repeated close of a known closing/closed session is safe and returns an idempotent success result.
A completely unknown session ID still returns SESSION_NOT_FOUND.
browser_runtime_info
browser_session_create
browser_session_list
browser_session_get
browser_session_close
browser_page_create
browser_page_list
browser_page_close
browser_navigate
browser_back
browser_forward
browser_reload
browser_get_url
browser_get_title
browser_snapshot
browser_visible_text
browser_snapshot is bounded by default and may be restricted with a semantic/CSS scope,
interactiveOnly, per-node maxChildren, maxDepth, includeBoundingBoxes, maxChars, and
maxBytes. Its structured result reports every applied bound, intentional tree omission, and
character/UTF-8 byte count. When either response cap is reached,
partial=true, truncation.truncated=true, and contentFormat=aria-yaml-fragment; do not parse
that fragment as a complete ARIA YAML document. Password values remain redacted. Set
includeRefs=true to receive at most maxRefs (default 50, maximum 100) opaque interactive-element
refs for immediate follow-up actions. Refs expire after 30 seconds, are scoped to the exact
session/page, and become stale after navigation, DOM replacement, page close, expiry, or a newer
ref snapshot. A non-null nextCursor continues the same immutable captured serialization without
rereading a changed DOM. Cursors are scoped to the exact session/page, expire after 30 seconds, and
become stale after navigation, page close, quota eviction, or shutdown. At most four paginated
snapshots and 1,000,000 Unicode code points per captured snapshot are retained per page.
Before native ARIA serialization, BrowserMesh also rejects a scope exceeding 20,000 DOM/text nodes
or 2,000,000 source characters. This pre-capture budget limits browser-side work independently of
the smaller per-response and retained-cursor bounds.
browser_observe
One tool reads all four recorded sources, selected by source: console, pageError, network,
or requestFailed. It requires an explicit sessionId and pageId, and echoes source so results
read into one buffer stay distinguishable.
Console and page-error reads are metadata-only by default; set includeText=true for bounded,
best-effort-redacted evidence. The two network sources carry no text and reject that flag rather
than returning a metadata-only answer that looks complete. Use nextCursor as the next
non-destructive sinceEventId checkpoint. Always inspect gap and droppedCount before concluding
that an event was absent. Text may be truncated further to satisfy the total response-byte limit;
the event and its cursor are still returned so pagination cannot stall. BrowserMesh never captures
console argument objects or raw error stacks.
Network reads expose only correlated request/response/request-failed metadata: a bounded request
ID, method, sanitized URL, resource type, status, duration, and safe failure classification where
applicable. Credentials and fragments are removed and sensitive query values are redacted before
storage. Headers, bodies, cookies, storage, service-worker traffic, WebSockets, data: URLs, and
blob: URLs are excluded. Page-originated HTTP(S) EventSource requests are included as ordinary
network metadata. HTTP error responses such as 500 appear under source: "network"; only
transport-level failures appear under source: "requestFailed".
Before 0.2 these were four tools —
browser_console_list,browser_page_errors_list,browser_network_list, andbrowser_failed_requests_list— publishing four copies of one contract. Pass the matchingsourceinstead.
browser_click
browser_double_click
browser_hover
browser_focus
browser_check
browser_uncheck
browser_scroll_into_view
browser_scroll
browser_drag_and_drop
browser_fill
browser_press
browser_select_option
These typed operations accept exactly one semantic/CSS locator or short-lived snapshot ref. They are explicitly
addressed, bounded by timeoutMs, cancellation-aware, and serialized with all browser work in the
owning session. check and uncheck ensure the requested state idempotently. browser_scroll
accepts bounded integer pixel deltas (deltaX and deltaY from -1,000,000 through 1,000,000),
while drag-and-drop resolves both source and target with the same strict locator semantics. None of
these tools exposes arbitrary page JavaScript.
browser_wait
browser_action_and_wait
browser_wait observes one passive, typed condition through the owning session queue: an exact or
safe-glob URL, domcontentloaded/load, locator state, or bounded text presence/absence. Text
matching is a case-sensitive substring check against at most the first 1,000,000 characters of
the page body's rendered innerText; absent means that substring is not present in that bounded
observation. Caller regular expressions, JavaScript predicates, arbitrary sleeps, and
networkidle are not supported.
Do not queue a passive wait before the same-session action expected to satisfy it.
browser_action_and_wait registers a typed navigation, HTTP response, popup, or dialog waiter first
and then performs one click or key press under one shared deadline. Returned response URLs remove
credentials and fragments and redact common sensitive query values. A popup is assigned a new
managed pageId in the same session with isDefault=false; overflow popups are closed before
LIMIT_EXCEEDED is returned. Dialogs are handled atomically with an expected type and accept/dismiss
choice because a blocking dialog cannot be safely inspected later. Prompt input and returned dialog
metadata are bounded.
browser_action_and_wait addresses its action with target, taking a semantic/CSS locator or a
snapshot ref exactly like the standalone interaction tools. Neither result restates the request:
browser_wait returns satisfied, and browser_action_and_wait returns the observed event. The
caller already holds the condition and action it sent, and operationId correlates the result.
browser_screenshot
Screenshots are returned as MCP image content instead of being written to a caller-controlled
filesystem path. The optional capture mode selects the viewport, the full scrollable page, or one
strictly resolved semantic/CSS element; the default remains the viewport. Structured output reports
actual PNG width, height, and encoded bytes. BrowserMesh measures CSS-pixel dimensions before capture
and validates actual PNG dimensions and bytes afterward. Full-page and element modes capture the
fixed measured clip, so later page growth cannot expand native image allocation. Configured
overflow returns LIMIT_EXCEEDED and does not poison the session queue.
browser_state_save
browser_state_list
browser_state_remove
browser_session_create accepts an optional stateId.
Without stateId, it creates a fresh isolated context.
With stateId, it initializes the new context using a previously saved BrowserMesh state.
Saved-state count, individual bytes, and aggregate bytes are centrally bounded. Quota checks and atomic replacement are serialized across all state IDs; a rejected replacement preserves the old state. Existing files are size-checked and read with a hard bound before JSON parsing.
browser_session_create also accepts an optional contextSettings object for an isolated viewport,
device scale factor, locale, timezone, color scheme, reduced-motion preference, and user agent. The
session result returns the normalized effective settings. Use separate sessions for different
device/accessibility/permission profiles. Geolocation is optional and the only supported browser
permission is an explicit grant to one absolute HTTP(S) origin. Wildcards and arbitrary permission
names are rejected.
browser_session_create({
name: "mobile-fr",
contextSettings: {
viewport: { width: 390, height: 844 },
deviceScaleFactor: 3,
locale: "fr-FR",
timezoneId: "Europe/Paris",
colorScheme: "dark",
reducedMotion: "reduce"
}
})Geolocation access must be scoped to the exact application origin:
browser_session_create({
name: "local-map-test",
contextSettings: {
geolocation: { latitude: 41.3111, longitude: 69.2797, accuracy: 25 },
permissions: [
{ permission: "geolocation", origin: "https://maps.example.test" }
]
}
})The permission is isolated to that session context and is removed when the session closes. Saved storage state does not contain or restore BrowserMesh permission grants.
Example conceptually:
browser_session_create({
name: "buyer",
stateId: "buyer-auth"
})A session may have:
an optional human-readable name;
optional string metadata.
For example an external AI client may label sessions:
role=buyer
role=seller
account=workThese values are neutral workflow labels only.
They do not create:
internal Agent entities;
ownership principals;
permissions;
mailboxes;
message channels;
LLM identities.
BrowserMesh tool descriptions are part of the product contract.
Descriptions must explain both what a tool does and when an AI client should use it.
For example, the description for browser_session_create must make it clear that separate sessions should be used for:
different users;
different accounts;
different roles;
different authentication states;
independent parallel browser workflows.
The goal is that a user can say:
Test this application as a buyer and an administrator.
without having to manually instruct the AI to call browser_session_create twice.
Every discovered tool also publishes a human-readable title, an object-root outputSchema, and
reviewed MCP risk hints (readOnlyHint, destructiveHint, idempotentHint, and openWorldHint).
These hints improve client UX only; BrowserMesh never treats them as authorization.
Successful calls return schema-validated structuredContent with direct semantic fields. For
example, browser_session_create exposes operationId, session, and initialPage directly,
without a nested value.value envelope. A concise JSON text block remains for text-only clients.
Screenshots retain their in-memory MCP image block and add structured PNG/correlation metadata.
Application failures use isError: true and a bounded JSON error containing a stable code, safe
message, optional sanitized details, and operationId correlation when the runtime accepted the
operation. Raw causes, stacks, cycles, non-JSON values, and secret-bearing detail fields never cross
the MCP boundary. SDK input-schema failures remain distinguishable as MCP input-validation errors.
Browser actions prefer semantic locator strategies.
Supported v0.1 strategies include:
role;
text;
label;
placeholder;
test ID;
CSS as an escape hatch.
Common interactive role values are supported by the v0.1 public contract.
Role names use exact accessible-name matching by default. Set exact: false only when partial
matching is intentional. If a locator resolves to multiple elements, BrowserMesh returns
LOCATOR_AMBIGUOUS and keeps the session usable.
Any locator may optionally set frame to { "kind": "main" } or to a bounded
{ "kind": "iframe", "chain": [...] } of one through five outer-to-inner semantic/CSS iframe
element selectors. Each chain step must resolve exactly; numeric indexes and persistent frame
handles are not exposed. The same scope works for actions, locator waits, visible text, snapshot
scope/ref capture, element screenshots, and drag/drop endpoints. Cross-origin iframe content is
returned only when the caller explicitly requests that scoped evidence.
Accessibility snapshots redact non-empty values from input[type="password"] elements before any
snapshot content crosses the MCP boundary.
BrowserMesh does not expose Playwright Locator objects through its public API.
Element refs are conveniences for immediate snapshot-to-action workflows, not durable identity.
Invalid, expired, cross-page, or detached refs return STALE_ELEMENT_REFERENCE; semantic locators
remain preferred for durable tests. BrowserMesh does not use undocumented Playwright AI/ref
selectors or expose adapter-owned element handles.
BrowserMesh stores local persistence data beneath:
.browsermesh/by default.
Saved browser state may contain authentication credentials or equivalent sensitive browser state.
Therefore:
.browsermesh/ is ignored by Git;
saved state must not be committed;
saved state must not be published;
logs must not contain storage-state contents;
callers provide logical state IDs, not arbitrary filesystem paths.
Persistence represents serialized browser storage/auth state.
BrowserMesh never attempts to serialize a live BrowserContext, open pages, pending operations, or live browser process state.
Environment variable | Default | Meaning |
|
| Default bounded operation timeout |
|
| Private local data directory |
|
|
|
|
| Active session limit |
|
| Managed pages per session |
|
| Enable saved browser state |
|
| Launch Chromium without a visible window |
|
| Share repeated subschemas via |
|
| Download Chromium on first start if missing |
| (all) | Tool profiles to publish, comma-separated |
|
| Retained mixed observability events per page |
|
| Maximum exposed event string length |
|
| Maximum events returned by one read |
|
| Maximum serialized observability response size |
|
| Maximum PNG width or height in CSS pixels |
|
| Maximum total PNG pixels |
|
| Maximum encoded PNG bytes |
|
| Maximum returned Unicode code points |
|
| Maximum returned visible-text UTF-8 bytes |
|
| Maximum persisted logical states |
|
| Maximum bytes in one persisted state |
|
| Maximum aggregate persisted-state bytes |
The options the command line accepts are --headless, --headed, --timeout, --data-dir,
--log-level, --max-sessions, --max-pages, --tools, --no-persistence, --no-schema-refs,
and --no-auto-install. Each sets the variable above that already configures it, and the command
line wins. The remaining variables — the observability, screenshot, visible-text, and persistence
budgets — are set through the environment only. Run browsermesh --help for the current list. A
rejected value names the variable it came from and exits with status 2 instead of printing a stack
trace.
Saved state lives under the user's home directory rather than the working directory. An MCP client
starts BrowserMesh from whichever directory it happens to be in, so a relative default scattered
saved authentication across unrelated folders and made browser_state_list come back empty for no
visible reason. Pass --data-dir .browsermesh for the previous project-scoped behaviour.
Configuration is read and validated centrally.
Discovery costs context, once per session, in every client. --tools narrows what BrowserMesh
publishes to the profiles a workflow actually needs:
Profile | Tools | Contents |
| 31 | Sessions, pages, navigation, reading, interaction, waits, capture |
| 1 |
|
| 3 |
|
Omitting --tools publishes every profile, so an existing configuration keeps the tools it had.
npx -y browsermesh --tools core,persistencePublished schemas share their repeated subschemas through $defs/$ref, which every JSON Schema
2020-12 validator resolves. Set --no-schema-refs for a client whose validator does not.
BrowserMesh publishes two MCP prompts, so a client can offer the workflow rather than having to infer it:
parallel_roles — carry one task out as several roles at once, one isolated session each.
diagnose_page — load a page and collect console, page-error, and network evidence about it.
It also publishes one read-only resource, browsermesh://sessions, listing the sessions the runtime
currently holds with their status and labels.
Both are static templates. BrowserMesh renders text and returns it; it makes no LLM call and keeps no per-client state. The client still reasons and decides which tools to call.
BrowserMesh launches Chromium in headed mode by default so the user can observe browser automation.
Set BROWSERMESH_HEADLESS=true for CI, servers, and other environments without a display. Only the
literal values true and false are accepted; invalid values fail configuration instead of being
silently ignored. Browser startup remains lazy in either mode, so MCP discovery and actionable
setup errors stay available when Chromium has not been installed yet. The configured
BROWSERMESH_TIMEOUT_MS also bounds browser launch. Set a larger per-tool timeoutMs only for
operations that are expected to take longer than the safe default.
Session labels are bounded even for direct runtime callers: names allow at most 128 Unicode code
points, metadata at most 32 entries, and keys/values have character, UTF-8 byte, and aggregate byte
limits. Control characters and dangerous object keys are rejected before BrowserMesh allocates a
session ID, context, or page. browser_visible_text retains its text field and adds explicit
truncation metadata so a client can distinguish complete evidence from a bounded prefix.
Direct scattered process.env access throughout the codebase is not allowed.
browser_runtime_info is safe to call before creating a session. It reports exact BrowserMesh,
Node, and resolved Playwright versions; effective configuration and limits; browser launch state;
nullable live Chromium version; and active/failed session counts. It does not launch Chromium and
does not expose paths, environment values, browser state, or raw failures.
MCP stdio reserves stdout for protocol traffic.
BrowserMesh structured logs therefore go to stderr.
Logs may contain safe correlation information such as:
operationId;
sessionId;
pageId;
tool/operation name;
duration;
safe error code.
Logs must not contain:
cookies;
tokens;
saved state;
page contents;
screenshots;
form values;
passwords;
arbitrary message payloads.
BrowserMesh does not silently reconstruct live sessions if Chromium unexpectedly disconnects.
Affected sessions transition to a failed state and their live handles are invalidated.
Existing sessions are never silently recreated because doing so would violate BrowserMesh state guarantees.
A fresh Chromium process may be started for future newly created sessions if the runtime can safely recover, but old live sessions remain failed.
npm run typecheck
npm run lint
npm run format:check
npm test
npm run test:integration
npm run test:e2e
npm run test:stress
npm run test:coverage
npm run build
npm run verifyBrowser integration/e2e tests use real Chromium together with a deterministic loopback HTTP test server.
Tests do not depend on public websites.
See:
Pull request titles follow Conventional Commits. Every PR is checked by the full test matrix, package-install smoke tests, semantic-title validation, and CodeQL. Releases are prepared by Release Please and published to npm through GitHub OIDC only after a maintainer merges the generated Release PR.
BrowserMesh is distributed under the Apache License 2.0.
BrowserMesh v0.1 intentionally does not include:
Firefox/WebKit parity;
remote Streamable HTTP;
BrowserMesh-hosted cloud infrastructure;
multi-tenant authentication;
distributed browser workers;
live-operation crash recovery;
internal Agent entities;
internal session ownership tied to LLM agents;
Agent registries;
mailboxes;
agent-to-agent messaging;
internal LLM calls;
prompt orchestration;
Claude/Codex/Qwen process spawning;
arbitrary shell execution;
arbitrary filesystem reads;
caller-controlled screenshot paths;
downloads;
web dashboard;
network allowlist;
full Playwright API.
A future generic client/workflow lease may be introduced if real multi-client protection requires it.
Such a lease must remain independent of LLM/Agent abstractions.
Within one BrowserMesh runtime:
sessions are explicitly addressed;
pages are explicitly addressed;
each session has an isolated browser context;
different sessions may execute concurrently;
operations targeting one session execute deterministically through that session's queue;
failures do not poison future queued operations;
persisted state is handled through controlled logical identifiers;
shutdown cleans up live browser resources;
BrowserMesh performs browser execution while reasoning remains outside the runtime.
Atomically register a navigation, response, popup, or dialog waiter first, then click or press on the explicitly addressed page under one shared deadline; the action locator may use a bounded semantic iframe chain. Popup pages receive a new BrowserMesh pageId in the same session with isDefault=false and are closed if the page limit is exceeded. Dialogs must be handled atomically because they cannot be inspected later; specify the expected type and accept/dismiss action. Returned dialog text is bounded. Use this instead of parallel same-session calls when an action triggers the event.
| Name | Required | Description | Default |
|---|---|---|---|
| wait | Yes | ||
| action | Yes | ||
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| event | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavior beyond the annotations: popup pages receive a new pageId with isDefault=false, may be closed on page-limit excess, dialogs must be handled atomically because they cannot be inspected later, and returned dialog text is bounded. This complements the binary readOnly/destructive/idempotent flags without contradicting them.
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 dense but front-loaded: the first sentence captures the core purpose and mechanism, and subsequent sentences cover popup behavior, dialog behavior, and usage. Every sentence adds information; there is no filler or repetition of schema details.
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 complex tool with nested wait/action/iframe schemas and no property descriptions, the description covers the key decision points: what can be waited on, what actions can be performed, iframe handling, popup semantics, dialog atomicity, and when to prefer this tool. Output semantics are also partially covered, and an output schema exists to handle return details.
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?
With schema description coverage at 0%, the description compensates substantially by explaining the wait variants (navigation, response, popup, dialog), dialog accept/dismiss semantics, prompt text bounding, and iframe-chain locators. It does not explicitly walk through sessionId/pageId/timeoutMs, but those are structurally covered by the schema and names are self-explanatory.
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 that the tool atomically registers a waiter (navigation, response, popup, or dialog) and then performs a click or press on a specifically addressed page. It also distinguishes itself from sibling tools by saying to use it instead of parallel same-session calls when an action triggers an event.
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 gives explicit usage context: use this when an action triggers a waitable event (navigation, response, popup, dialog) and when coordination matters. It names the alternative pattern (parallel same-session calls) but does not explicitly state when to fall back to simpler sibling tools like browser_click or browser_wait.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Navigate backward in the history of one explicitly addressed page without affecting pages or sessions used by other roles.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond the annotations by stating that only the specified page is affected, and other roles' pages/sessions remain untouched. This is valuable because the tool is a navigation action that mutates history position but is scoped. It does not contradict the annotations and provides useful isolation semantics.
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, well-structured sentence that states the action, scope, and isolation guarantee without unnecessary filler. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
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 simple nature, the presence of an output schema, and annotations, the description covers the essential behavior and scope. It does not cover edge cases such as behavior when there is no history, but that is likely acceptable for a low-complexity tool. The description is complete enough for basic invocation and role isolation.
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's parameter descriptions are absent (schema_description_coverage is 0%), so the description must compensate. It mentions page and session concepts indirectly, but it never explains the meaning of sessionId, pageId, or timeoutMs. The description alone is insufficient for an agent to know how to correctly populate the parameters.
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's function: 'Navigate backward in the history of one explicitly addressed page.' It uses a specific verb ('navigate backward') and resource ('history of a page'), and the phrase 'one explicitly addressed page' differentiates it from broader navigation or session-level tools. It is also distinct from sibling tools like browser_forward and browser_navigate.
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 gives useful context: the action applies to exactly one page and does not affect pages/sessions used by other roles. This clarifies the scope but does not explicitly state 'use this instead of browser_forward when...' or list exclusions. Thus context is clear, but explicit when/when-not alternatives are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Ensure a checkbox or radio located semantically or by CSS is checked on one explicitly addressed page. The operation is idempotent, bounded by timeoutMs, and isolated to the supplied session.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral details beyond annotations: it explicitly states idempotency, timeout bound (timeoutMs), and session isolation. It also clarifies the locator strategy (semantic or CSS). No contradictions with annotations.
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 concise sentences with no excessive detail. The description is well-structured and directly conveys the essential 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?
The description covers the main action and key constraints (idempotent, timeout, session). It does not delve into edge cases like element not found, but since an output schema exists (though not shown), return values are not required. Overall, it is sufficiently complete for typical 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?
The description only mentions timeoutMs and session indirectly. It does not explain the meaning of ref, pageId, or locator structure. Given the schema has 5 parameters with 0% description coverage, the description adds limited parameter meaning.
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 (ensure a checkbox or radio is checked) and specifies the target type and how it is located (semantically or by CSS). It also distinguishes from similar tools like uncheck by focusing on checking.
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 for checking checkbox/radio elements and mentions authentication via session, but it does not explicitly contrast with alternatives like browser_click or browser_uncheck. However, the purpose is clear enough to infer when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Click exactly one semantic/CSS locator or short-lived snapshot ref on one explicitly addressed page. A locator may select the top document or a bounded outer-to-inner semantic iframe chain. Role locator names match exactly by default and every iframe-chain selector must resolve exactly; ambiguous locators return LOCATOR_AMBIGUOUS and stale or cross-page refs return STALE_ELEMENT_REFERENCE. Prefer semantic locators for durable workflows.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses key behaviors beyond annotations: LOCATOR_AMBIGUOUS for ambiguous locators, STALE_ELEMENT_REFERENCE for stale or cross-page refs, exact resolution requirements for iframe chains, and role locator name exactness. These error semantics and constraint details are valuable and not present in the annotations.
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?
Three sentences, each earning its place: main behavior, locator/iframe constraints, and durability advice. Highly front-loaded and free of filler.
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 tool has a complex locator schema and an output schema, so return values need not be described. The description covers the dominant complexities—locator types, iframe chains, exact matching, and error cases—but omits timeout semantics and the required session/page addressing parameters, leaving a small gap given the tool's complexity.
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 0%, so the description must compensate. It adds meaning for locator strategies, iframe chains, snapshot refs, and exact matching, but it does not explain sessionId, pageId, timeoutMs, or the ref pattern format beyond calling it 'short-lived.' This is partial but incomplete compensation.
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 specifies a precise action: 'Click exactly one semantic/CSS locator or short-lived snapshot ref on one explicitly addressed page.' It clearly differentiates from sibling tools like browser_double_click, browser_hover, and browser_focus by emphasizing exactly one click and explicit page addressing.
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?
Provides clear context on locator types, iframe constraints, and exact-match behavior. The final advice 'Prefer semantic locators for durable workflows' gives actionable guidance, though it does not explicitly name alternatives or state when not to use this tool versus siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Double-click a semantic or CSS locator on one explicitly addressed page. Use this only when the application assigns distinct double-click behavior; the action is serialized with all browser work in that session and an ambiguous locator returns LOCATOR_AMBIGUOUS.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructive and non-idempotent behavior. The description adds value beyond that by mentioning that the action is serialized with all browser work in that session and that an ambiguous locator returns LOCATOR_AMBIGUOUS. This provides useful behavioral context not captured in structured metadata.
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 two sentences in length, front-loaded with the core purpose, and contains no redundant or vague phrasing. Every sentence adds meaningful information: the first defines the action, the second gives usage and behavioral caveats.
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 has 5 parameters with zero schema descriptions and is a mutation action, the description is incomplete. It lacks parameter explanations, prerequisites (e.g., page must be open), and return format details (though an output schema exists). The description covers usage guidance and some behavior but does not sufficiently compensate for the lack of schema details.
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 0%, so the description must compensate for undocumented parameters. However, it only mentions 'semantic or CSS locator' (giving some hint about the locator parameter) but says nothing about sessionId, pageId, ref, or timeoutMs. The description fails to explain the purpose or format of these parameters, leaving the agent without adequate guidance.
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: double-click a semantic or CSS locator on a specifically addressed page. It differentiates from siblings like browser_click by specifying 'only when the application assigns distinct double-click behavior' and 'one explicitly addressed page,' making the scope precise and distinguishing it from other browser interaction tools.
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 explicitly conditions when to use the tool ('only when the application assigns distinct double-click behavior'), which tells the agent not to use it for simple clicks. It also implies the need for a page context via 'explicitly addressed page,' but it does not explicitly name alternative tools like browser_click, leaving some room for inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Drag one semantic or CSS-located element onto another on one explicitly addressed page. Source and target are resolved in the same page and session, with bounded timeout and strict ambiguity errors.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| source | Yes | ||
| target | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and readOnlyHint=false, so the description doesn't need to restate that. It adds valuable context beyond annotations by mentioning bounded timeout and strict ambiguity errors, which inform error handling. It also clarifies that source and target must be on the same explicitly addressed page, a behavioral constraint not present in annotations. No contradiction with annotations.
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 concise two-sentence statement that leads with the core action and immediately provides essential scope and behavior details. Every phrase earns its place, with no fluff or redundant information. It front-loads the purpose and adds constraints efficiently.
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 complexity (drag and drop across frames, multiple locator strategies), the description provides a solid high-level overview: it covers the operation type, page scoping, session binding, timeout behavior, and ambiguity handling. It doesn't mention iframe support or the details of source/target resolution, but those are captured in the schema, and with an output schema present, return values needn't be described. The description is adequately complete for orientation, though a mention of iframe capability would improve completeness.
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 0%, so the description carries full responsibility for parameter explanation, but it only vaguely references 'semantic or CSS-located' elements. It doesn't mention sessionId, pageId, timeoutMs, or the structure of source/target. The schema itself is rich, but the description fails to bridge that gap for an agent that might not parse the JSON schema deeply. This falls short of compensating for the low 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: dragging a semantically or CSS-located element onto another, which directly distinguishes it from other browser interaction tools like click, hover, or fill. It also specifies the scope (one explicitly addressed page) and adds useful qualifiers (same page/session, bounded timeout, strict ambiguity errors), making the purpose unambiguous.
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 conveys when to use this tool (when dragging is required) and sets expectations about resolution (same page/session, timeout, ambiguity). It doesn't explicitly mention alternatives or when not to use it, but the context is clear enough for an agent to infer that this is the drag-and-drop operation among the sibling set.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill a form field located on one explicitly addressed page. The value is entered only in that session; use separate sessions for different identities.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| value | Yes | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish mutability and non-idempotency, so the description correctly carries no repetitive safety claims. The session/identity isolation disclosure adds genuine behavioral context beyond annotations: it tells the agent that the write is scoped to a session and that identity isolation requires separate sessions, which is operationally important for an openWorldHint=true tool. Slightly more detail (e.g., overwrite behavior on re-fill) would push it higher.
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?
Exactly two front-loaded sentences: the first delivers the core action with scope, the second adds the critical usage constraint. Zero filler words; every element serves purpose and usage communication.
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 genuine complexity (nested iframe selectors, multiple locator strategies, 6 params, 0% schema coverage), two sentences feel thin. The description covers page and session addressing well, but omits any mention of the iframe-chain capability, behavior on locator timeout (timeoutMs exists), or what happens when the field can't be found. The presence of an output schema and annotations mitigates some burden, landing this at minimum viable.
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?
With 0% schema coverage and a highly complex polymorphic locator parameter (role/text/label/placeholder/testId/css strategies, iframe chains up to 5 deep, exact-match flags), the description should compensate significantly. It only loosely maps to two of six params ('form field'→value/locator, 'explicitly addressed page'→pageId, 'session'→sessionId) while ignoring the locator complexity, ref-slot, and timeout semantics. The description's contribution is limited to the session-scoping nuance.
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 uses a specific verb+resource ('Fill a form field') with a clear scope qualifier ('located on one explicitly addressed page') that establishes a page-addressability constraint. It clearly differentiates the tool's scope from page-level operations, though it doesn't explicitly distinguish itself from close form-related siblings like browser_check or browser_select_option (e.g., it doesn't say 'for text inputs, use fill; for checkboxes, use check').
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 session-scoping rule ('value is entered only in that session') provides clear context for when this tool applies, and 'use separate sessions for different identities' is a genuine usage directive. However, it never explicitly names alternatives among the 35 siblings or states when NOT to use this tool in favor of browser_press, browser_check, or browser_select_option.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Focus a semantic or CSS locator on one explicitly addressed page without entering a value. Use this for focus-driven UI state or before a separate key action; the locator remains scoped to the supplied sessionId and pageId.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already signal readOnlyHint=false, idempotentHint=true, and openWorldHint=true, and the description adds the useful scoping detail that 'the locator remains scoped to the supplied sessionId and pageId.' However, it does not disclose potential side effects implied by the open-world hint (e.g., whether focus changes page state or fires events), so it adds only moderate value beyond annotations.
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 front-loaded sentences with zero waste. The first sentence states the action and its key qualifier ('without entering a value'), and the second provides usage context and scoping. Every word earns its place.
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 complexity (frame chains, multiple locator strategies, exact-match options) and the presence of an output schema, the description is functionally adequate. However, the openWorldHint suggests behavioral side effects that go undisclosed, and edge cases like missing elements or visibility requirements are unaddressed, leaving meaningful gaps for a complex 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?
With 0% schema description coverage, the description is expected to compensate, and it partially does by naming sessionId and pageId and clarifying that 'locator' can be semantic or CSS. However, timeoutMs and ref are completely unaddressed, and the locator's frame/strategy options are left to the schema enums, so compensation is meaningful but incomplete.
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 uses a specific verb+resource: 'Focus a semantic or CSS locator on one explicitly addressed page without entering a value.' The qualifier 'without entering a value' clearly distinguishes it from sibling actions like browser_fill or browser_press, and the scoping to sessionId/pageId adds precision. It clearly differentiates from the sibling list where fill/click/observe exist.
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 phrase 'Use this for focus-driven UI state or before a separate key action' provides an explicit when-to-use trigger. However, it does not name specific alternatives or give when-not-to-use exclusions for cases where focus is unnecessary, resulting in good but not fully explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Navigate forward in the history of one explicitly addressed page without affecting other isolated sessions.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate that the tool is not read-only (readOnlyHint: false), not idempotent, and not destructive, but the description adds that it affects only the specified page and not other sessions, which is useful context. However, it does not disclose details like what happens if there is no forward history, or if any errors are expected. The description does not contradict annotations, but the added value is moderate.
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, consisting of a single sentence that conveys the essential purpose and a key constraint. It is front-loaded and has no wasted words, making it easy for an agent to parse quickly.
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 tool is relatively simple with a clear purpose, but it lacks information about error handling (e.g., what happens when there is no forward history) and potential edge cases. The presence of an output schema might clarify return values, but the description does not mention them. Given the simplicity, a 3 is appropriate as it meets basic needs but leaves some gaps.
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?
Since the schema description coverage is 0%, the description must compensate, but it does not explicitly explain the parameters. However, the parameters are self-explanatory: sessionId and pageId are required to identify the page, and timeoutMs is optional and likely for controlling the wait time. The description's statement about addressing one page implicitly covers the need for sessionId and pageId, and the timeoutMs is optional as per the schema. Overall, the semantics are clear from the context.
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 navigates forward in browser history, using a specific verb and resource. It distinguishes itself from the sibling tool browser_back by explicitly mentioning 'forward', and it also notes the operation is scoped to a specific page without affecting other sessions. However, it does not explicitly mention the sibling tool browser_navigate for direct URL navigation, which could be considered an alternative.
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 that this tool should be used when you need to go forward in history on a specific page, but it does not explicitly state when to use it versus alternatives like browser_back or browser_navigate. It provides some context by mentioning 'explicitly addressed page' but lacks clear guidance on when not to use it or which other tools to consider.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the title of one explicitly addressed page in its owning isolated session.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| title | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already communicate readOnly, idempotent, non-destructive behavior. The description adds that the page is explicitly addressed and tied to an isolated session, but does not disclose failure behavior or what happens when no title exists. No contradiction with annotations.
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 compact sentence that is front-loaded with the action and resource. There is no filler or redundancy; every phrase adds useful scoping 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?
Given the low complexity, strong annotations, and presence of an output schema, the description is mostly sufficient. It identifies the target resource and required session context, though it omits optional timeout semantics and alternative-tool guidance.
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 0%, so the description must compensate. It loosely maps pageId to 'explicitly addressed page' and sessionId to 'owning isolated session', but it does not explain timeoutMs or provide any additional format/meaning for the parameters beyond their names.
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 uses a specific verb ('Read') and resource ('title of one explicitly addressed page'), and clarifies the required session context. This distinguishes it from sibling tools like browser_get_url or browser_visible_text while stating exactly what value is returned.
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 clearly implies the tool is for reading a page's title when you have an explicit page and session. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any exclusions or prerequisites beyond the required IDs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the current URL of one explicitly addressed page. Use the IDs returned for the intended session; there is no global current page.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that there is no global current page, a behavioral trait not covered by annotations. It also reinforces the read-only nature implied by the annotations without contradicting them.
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 and well-structured, consisting of two clear sentences that directly convey the necessary information without redundancy.
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 does not specify the return value or potential error conditions, but for a simple read operation with readOnly and idempotent annotations, it may be sufficiently complete for typical 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?
The description hints at the need for sessionId and pageId by mentioning 'IDs returned for the intended session', but it does not explain timeoutMs. Since the schema provides no parameter descriptions, the description only partially compensates.
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 that the tool reads the current URL of a specific page and explicitly requires addressing. It distinguishes itself from any global current page concept, making the purpose unambiguous.
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?
It provides guidance that IDs are necessary because there is no global current page, but it does not explicitly contrast with alternative tools or specify when to choose this over other navigation or read operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Move the pointer over a semantic or CSS locator on one explicitly addressed page. Use this to reveal hover-driven controls or state before inspecting or interacting; BrowserMesh preserves same-session accepted order.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations include readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds that BrowserMesh preserves same-session accepted order, which is a behavioral trait not covered by annotations. However, it doesn't disclose potential side effects (e.g., triggering JavaScript events, changing page state) beyond the hover action. With annotations providing some safety profile, the description adds some value but could be more transparent about what happens after hover.
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 two sentences, concise and front-loaded with the action. It includes a practical hint about same-session order. No wasted words, but it could be slightly more structured with explicit parameter guidance. Overall, it's efficient.
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 complexity of the input schema (nested locator definitions, frame chains, multiple strategies) and the lack of schema description coverage, the description is insufficient. It doesn't explain how to specify iframe contexts, the role-based locator structure, or the meaning of 'ref'. The output schema exists but the description doesn't clarify what the tool returns. For a tool with such a complex schema, the description should provide more guidance.
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 0%, so the description must compensate for parameter meaning. The description mentions 'semantic or CSS locator' and 'explicitly addressed page', which hints at locator and pageId parameters, but it doesn't explain the 'ref' parameter, 'timeoutMs', or the 'frame' structure. The schema is complex with nested definitions, and the description provides minimal guidance on how to construct the locator object. This is a significant gap.
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's purpose: moving the pointer over a semantic or CSS locator on an explicitly addressed page. It distinguishes from siblings like browser_click and browser_focus by specifying the hover action and its use case (revealing hover-driven controls). However, it doesn't explicitly differentiate from other hover-related tools (none exist in siblings), so it's clear but not fully distinguishing.
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 context on when to use the tool: 'Use this to reveal hover-driven controls or state before inspecting or interacting.' It implies usage before other actions, but doesn't explicitly state when not to use it or mention alternatives. The sibling list includes browser_click, browser_focus, etc., but no explicit comparison is made. This is clear context but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read bounded observations recorded for one explicitly addressed page. Choose source: 'console' for console events, 'pageError' for uncaught page errors, 'network' for correlated request/response metadata, or 'requestFailed' for transport-level failures. HTTP error responses such as 500 are 'network' response events, not 'requestFailed'. Console and page-error results are metadata-only unless includeText=true, which the network sources reject because they carry no text; exposed text is best-effort redacted and bounded, and console argument objects and raw stacks are never captured. Network URLs remove credentials and fragments and redact sensitive query values; headers, cookies, bodies, storage, WebSockets, service-worker traffic, data URLs, and blob URLs are never captured. Use sinceEventId as a non-destructive checkpoint and inspect gap and droppedCount before treating the evidence as complete.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| pageId | Yes | ||
| source | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No | ||
| includeText | No | ||
| sinceEventId | No |
| Name | Required | Description |
|---|---|---|
| gap | Yes | |
| events | Yes | |
| pageId | Yes | |
| source | Yes | |
| sessionId | Yes | |
| nextCursor | Yes | |
| operationId | Yes | |
| droppedCount | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond the readOnly/idempotent annotations by detailing privacy and completeness limitations: credentials and fragments are removed, headers/cookies/bodies/storage/WebSockets/service workers/data URLs are never captured, console stacks are omitted, text is best-effort redacted, and sinceEventId use is explicitly non-destructive. It also warns that results may be incomplete and to inspect gap and droppedCount.
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 front-loaded with the core purpose and packs substantial behavioral detail into a compact paragraph without filler or redundant schema repetition. It is dense and somewhat long, but the complexity of the tool justifies the 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 the tool's complexity, 7 parameters, and output schema, the description is very complete. It documents source semantics, text retrieval behavior, exclusions, redaction, checkpoint usage, and completion caveats. The rendered output schema covers the remaining response structure, so the description does not need to explain return values itself.
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?
Although the schema has 0% description coverage, the tool description compensates strongly for the most important parameters: 'source' receives detailed enum semantics, 'includeText' is explained with its restrictions, 'sinceEventId' is described as a non-destructive checkpoint, and sessionId/pageId map to 'one explicitly addressed page.' Less direct attention is given to limit, timeoutMs, and their defaults, so it stops short of a full score.
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 begins with a specific verb and resource: 'Read bounded observations recorded for one explicitly addressed page.' It then distinguishes the four source types, making it clear the tool is for observing console, page-error, network, and request-failed events, which separates it from the snapshot/visible-text/state siblings.
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 gives explicit guidance on when to use each source, notably distinguishing network responses from requestFailed events and explaining when includeText is meaningful. It does not explicitly mention alternatives among the sibling tools, but it provides strong within-tool selection guidance and advises inspecting gap and droppedCount before treating evidence as complete.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close one explicitly addressed page in its owning session. Supply both IDs because BrowserMesh has no global current session or page.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| closed | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark destructiveHint:true and readOnlyHint:false, so the description only adds the context that there is no global session/page. This is helpful but does not disclose other behavioral details like side effects on the session if it's the last page. With annotations provided, this is adequate.
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 action and purpose, and adds no unnecessary details.
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 close operation with annotations covering destructive behavior and an output schema present, the description provides the essential context about why both IDs are needed. It is concise and adequate, though it could note potential side effects if the last page is closed.
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 schema has 0% coverage, so the description must compensate. It explains that both IDs are needed to unambiguously address a page, but does not individually describe what each ID refers to. It adds some context but leaves the distinction between sessionId and pageId implied
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's action: 'Close one explicitly addressed page in its owning session.' It specifies the resource (page) and context (session), and distinguishes from siblings like browser_session_close and browser_page_create.
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 that both IDs are required because 'BrowserMesh has no global current session or page,' but it does not explicitly state when to use this tool over alternatives, nor provide exclusion criteria. It lacks explicit usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create an additional page inside one explicitly addressed session. Use it for another tab that must share that session's cookies and storage; use a separate session instead when identity or authentication must be isolated.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| page | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is not read-only (readOnlyHint: false). The description adds valuable behavioral context about cookie/storage sharing with the session and advises when isolation is needed. It does not disclose all potential side effects (e.g., that a new tab might appear visibly), but it goes beyond annotations by explaining the sharing semantics, which is useful for the agent.
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 consists of two sentences with no redundancy. The first sentence gives the core action, the second provides usage context. Every word contributes to the meaning, and it is front-loaded with the essential purpose.
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 parameter, the description fully covers the main use case and contrasts it with an alternative. It does not detail what the created page looks like or how it behaves initially, but an output schema is present (context signal shows), which likely covers return values. The sharing/isolation guidance makes the tool's context clear enough 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 0%, so the description must compensate for parameter explanation. It mentions 'explicitly addressed session,' which implies the single parameter sessionId identifies the target session, but it does not explicitly state that sessionId is the unique identifier for the session. This is implicit rather than direct, so it only partially compensates for the lack of schema documentation.
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's function: 'Create an additional page inside one explicitly addressed session.' This uses a specific verb (create) and resource (page), scoped to a session, and distinguishes it from sibling tools like browser_session_create (which creates sessions) and browser_page_close (which closes pages). The purpose is unambiguous.
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 explicit usage guidance: 'Use it for another tab that must share that session's cookies and storage; use a separate session instead when identity or authentication must be isolated.' This clearly states when to use this tool versus when to use a separate session, offering a concrete alternative and exclusion condition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List pages belonging only to the addressed session. Session creation already returns the initial pageId; use this tool to rediscover or inspect all pages in that session.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| pages | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds that it lists pages 'belonging only to the addressed session', which clarifies scope but does not add much beyond annotations. It does not describe return format or pagination, but with annotations covering safety, a 3 is appropriate.
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 two sentences, front-loaded with the purpose, and every word adds value. It is concise and well-structured.
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 tool is simple with one parameter and an output schema exists, so the description need not explain return values. The description covers the purpose and usage context adequately. It could mention that it returns a list of page IDs, but the output schema likely covers that. Given the simplicity and annotations, the description is complete enough.
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 0%, but there is only one parameter (sessionId) with a clear name and type. The description mentions 'addressed session' which implies the sessionId parameter, but does not add detailed semantics beyond what the schema provides. Since the parameter is self-explanatory and the description references it, a 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?
The description clearly states the tool lists pages belonging to a specific session, using the verb 'List' and specifying the resource 'pages' and scope 'session'. It distinguishes from siblings like browser_session_list (which lists sessions) and browser_page_create (which creates pages).
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 clear context: it is used to rediscover or inspect all pages in a session, and notes that session creation already returns the initial pageId. It implies when to use this tool (when you need to see all pages in a session) but does not explicitly mention alternatives or when not to use it, though the sibling list makes alternatives apparent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press a key on a locator within one explicitly addressed page, preserving deterministic ordering with other operations in that session. A missing or unsuitable element returns OPERATION_TIMEOUT within timeoutMs (10 seconds by default) without closing MCP or browser sessions.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | ||
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds valuable behavioral details: error handling (returns OPERATION_TIMEOUT) and that it does not close MCP or browser sessions on failure. This goes beyond the annotations and provides actionable information for an agent. No contradiction with annotations.
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, both directly relevant. The first states the action and a key behavioral constraint (deterministic ordering). The second covers error handling and session preservation. No clutter or redundant phrasing.
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 main action and error behavior, and an output schema exists (so return format is handled elsewhere). However, with six parameters and zero schema descriptions, the description does not fully compensate for parameter ambiguity. It is adequate but not thorough for a mutation tool with destructive 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 0%, so the description must compensate. The description only mentions timeoutMs ('within timeoutMs (10 seconds by default)') and implies 'locator' but does not explain sessionId, pageId, key, ref, or the locator structure. This is a significant gap; the agent cannot infer parameters from the description alone.
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: 'Press a key on a locator within one explicitly addressed page'. It also distinguishes this from siblings like browser_click (mouse action) and browser_fill (text input) by focusing on keyboard key presses. The verb and resource are specific, and the phrase 'within one explicitly addressed page' adds scope.
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 gives context about usage: it operates on a specific page and preserves deterministic ordering with other operations. However, it does not explicitly mention alternatives or when not to use this tool (e.g., when to use browser_fill or browser_click instead). The context is clear but lacks explicit exclusions or comparison to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Reload one explicitly addressed page in its existing isolated session and authentication state.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the core behavioral profile is covered. The description adds the key context that it operates within an existing session and preserves authentication state, which is useful. However, it does not mention potential side effects like unsaved form loss or network requests, so it adds only moderate value beyond annotations.
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, well-structured sentence that conveys the action and key constraints without unnecessary words. It is concise and front-loaded.
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 reload action, the description covers the essential context: it must target an existing page in an isolated session and preserves authentication. The output schema exists, so return values need not be described. It could mention waiting for load or error conditions, but given the tool's simplicity and annotation coverage, it is reasonably complete.
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 schema has 0% description coverage, so the description must compensate. It mentions 'explicitly addressed page' but does not explain sessionId, pageId, or timeoutMs. The parameter names are self-explanatory, but the description adds no additional meaning about how to use them or what timeoutMs controls, making it insufficient for a tool with undocumented parameters.
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 reloads a specific page within an existing session and auth state. The verb 'reload' is specific, and it distinguishes from navigation tools like 'navigate', 'back', and 'forward' by focusing on refreshing the current page.
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 by requiring an 'explicitly addressed page' in an 'existing isolated session', which tells the agent it needs a session and page already open. It provides clear context but does not explicitly name alternatives or when-not scenarios, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Report bounded, read-only BrowserMesh version, launch state, effective configuration, and session counts without launching Chromium. Use this to diagnose setup and capacity safely; it never returns paths, launch arguments, environment values, browser state, or raw errors.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| headless | Yes | |
| maxSessions | Yes | |
| nodeVersion | Yes | |
| serverVersion | Yes | |
| activeSessions | Yes | |
| browserProduct | Yes | |
| browserVersion | Yes | |
| failedSessions | Yes | |
| resourceLimits | Yes | |
| defaultTimeoutMs | Yes | |
| playwrightVersion | Yes | |
| browserLaunchState | Yes | |
| maxPagesPerSession | Yes | |
| persistenceEnabled | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnly, idempotent, non-destructive), the description adds valuable transparency by explicitly stating what the tool never returns (paths, launch arguments, environment values, browser state, raw errors). This gives users a clear picture of the tool's limitations and 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?
The description is concise and well-structured: two sentences that immediately state the action and scope, followed by a usage note and exclusions. No superfluous wording, and the information is front-loaded.
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 has no input schema and the description lists what it returns (version, launch state, configuration, session counts) and what it excludes, it is complete for a diagnostic tool. The sibling tools are all action-oriented (create, close, navigate, etc.), so this runtime info tool is clearly differentiated.
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 tool has no parameters, so schema coverage is effectively 100%. The baseline for zero parameters is 4. The description does not need to explain parameters, and it doesn't mislead. It adequately conveys the tool's input requirements (none).
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's purpose: reporting BrowserMesh runtime information (version, launch state, effective configuration, and session counts) without launching Chromium. It uses a specific verb 'report' and resource 'BrowserMesh runtime', and distinguishes itself from action-oriented sibling tools by explicitly mentioning it does not launch Chromium.
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 explicit guidance: 'Use this to diagnose setup and capacity safely'. It also contrasts with launching Chromium, implying when not to use it (i.e., when you need to launch or interact with the browser). This gives clear when-to-use and when-not-to-use context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Capture a bounded in-memory PNG screenshot of one explicitly addressed page, either as the viewport/full page or one semantic element optionally reached through a bounded iframe chain. Full-page and element capture use an immutable measured CSS-pixel clip plus encoded-byte validation. BrowserMesh returns image content and does not write to a caller-controlled path or inspect another session.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| capture | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| bytes | Yes | |
| width | Yes | |
| height | Yes | |
| pageId | Yes | |
| mimeType | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by stating the screenshot is bounded in-memory, uses measured CSS-pixel clips, performs encoded-byte validation, and does not write to caller-controlled paths or inspect other sessions. This adds meaning beyond the annotations, justifying a 4.
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 paragraph of about three sentences, front-loaded with the core action and then detailing constraints. It is compact with no filler, but it could be more structured (e.g., bullet points) to separate capture modes. Still, it is efficient and earns a 4.
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 tool is moderately complex with several capture modes and iframe support, but the schema and output schema provide substantial detail. The description covers scope, bounds, and safety without needing to explain return values. It misses some edge-case guidance (e.g., what happens on invalid locators), but given the richness of the schema, it is complete enough for an agent to act correctly.
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 0% according to context, so the description must carry the load. The description mentions 'explicitly addressed page' and 'bounded iframe chain,' which clarifies the frame parameter and element selection, but it does not explain the semantics of sessionId, pageId, or timeoutMs exhaustively. Since the schema itself is rich with enums and descriptions for those fields, the description adds only marginal value, so a 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?
The description clearly states the tool captures a bounded screenshot of a single page or element, with specific modes (viewport, full page, element) and constraints. It distinguishes itself from siblings like observe or snapshot by focusing on image capture, and the description's specificity (e.g., 'bounded in-memory PNG') makes the purpose unmistakable.
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 by specifying capture modes and options like iframe chains, and states a key limitation: it does not write to caller-controlled paths. It does not explicitly mention alternatives or when not to use it (e.g., for text extraction), but the context is clear enough for an agent to infer appropriate use cases, so it earns a 4 rather than 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scroll an explicitly addressed page by bounded integer pixel deltas. Use deltaX for horizontal and deltaY for vertical movement; this typed operation exposes no arbitrary JavaScript and remains serialized within the session.
| Name | Required | Description | Default |
|---|---|---|---|
| deltaX | Yes | ||
| deltaY | Yes | ||
| pageId | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond the annotations by stating that the operation is 'typed', 'exposes no arbitrary JavaScript', and 'remains serialized within the session.' This reassures the agent about safety and execution ordering, though it does not mention side effects like scroll-triggered lazy loading or clamped deltas. No contradiction with annotations is present.
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 efficient sentence that front-loads the core action and then adds parameter guidance and a safety note. Every clause contributes useful information with no redundancy or filler.
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 is adequate for a straightforward pixel-scroll operation, covering purpose, main parameters, and safety characteristics, and an output schema exists. However, it does not mention timeout behavior, how the scroll is clamped, or how this tool differs from browser_scroll_into_view, leaving some contextual gaps for an agent selecting among similar browser tools.
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?
With 0% schema description coverage, the description is responsible for explaining parameters, but it only covers deltaX and deltaY briefly. It does not explain sessionId, pageId, or timeoutMs semantics beyond the phrase 'explicitly addressed page', leaving required parameters partially unexplained.
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 scrolls a page by deltaX/deltaY pixel values, distinguishing it from sibling tools like browser_scroll_into_view by specifying bounded integer deltas rather than element-based scrolling. The verb 'Scroll' plus the explicit resource ('an explicitly addressed page') and mechanism ('by bounded integer pixel deltas') make the purpose precise and differentiated.
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 for precise pixel-based scrolling and provides guidance on which delta parameter controls which axis, but it does not explicitly state when to prefer this tool over browser_scroll_into_view or other browsing tools. No exclusions or alternative tool references are given, leaving the when-to-use decision mostly inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scroll one semantic or CSS locator into the viewport of an explicitly addressed page. Use this before inspection or interaction when an off-screen target must become visible; it never accepts arbitrary JavaScript or coordinates.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate idempotence and non-destructiveness, and the description adds important behavioral constraints: it only accepts locators, never arbitrary JavaScript or coordinates. It does not discuss failure modes or visibility guarantees in detail, but the annotations reduce the burden.
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 two sentences long, front-loaded with the core purpose, and contains no redundant filler. The usage guidance and constraint are expressed in the same concise description.
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 annotations, output schema, and reasonably self-describing sibling tool names, the description is mostly complete for a focused scrolling tool. It could improve by mentioning the element ref parameter or timeout behavior, but the core workflow is clear.
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 0%, so the description must compensate for parameter meaning, but it only explains the locator concept and the 'explicitly addressed page' idea. It does not explain optional parameters such as ref or timeoutMs, nor does it clarify how sessionId and pageId combine to address the page.
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: scroll a semantic or CSS locator into the viewport of a specific page. It also differentiates the tool from siblings by emphasizing that the target is a locator and that arbitrary JavaScript and coordinates are never accepted.
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 gives a concrete use context: use before inspection or interaction when an off-screen target must become visible. It does not explicitly name or contrast alternative browsing tools such as browser_scroll, so it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Select an option on one explicitly addressed page using a semantic or CSS locator. A missing or unsuitable select returns OPERATION_TIMEOUT within timeoutMs (10 seconds by default), and the supplied session plus all other sessions remain usable.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| value | Yes | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations show readOnlyHint=false and destructiveHint=false, but the description adds that a missing or unsuitable select returns OPERATION_TIMEOUT within timeoutMs and that the session remains usable. This provides behavioral context beyond annotations, such as error behavior and session safety, which is valuable for an agent.
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, concise sentence that includes key information: the action, the target, the locator types, and error behavior. It is front-loaded and every phrase adds value, with no redundancy.
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 tool is relatively complex with 6 parameters and a nested locator schema. The description covers the basic purpose and error behavior but lacks details on return values (though output schema exists), prerequisites for session/page existence, and specific examples of locator usage. With an output schema present, return values are covered, but the description still misses important context like how to construct locators or handle multiple selects.
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 schema has 6 parameters with 0% description coverage, so the description should compensate. While the description mentions using 'semantic or CSS locator' and 'timeoutMs', it does not explain specific parameters like sessionId, pageId, value, or the locator structure. The description adds minimal meaning beyond what the schema already defines, so it bears some responsibility for parameter clarity. Since schema coverage is 0%, the description should have done more, but it at least hints at the locator and timeout.
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 selects an option on a page using a semantic or CSS locator. It specifies the target resource (explicitly addressed page) and the action (selecting an option), which differentiates it from other browser interaction tools like click, fill, and check.
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 for selecting options from dropdowns but does not explicitly contrast with alternatives like click or check. It mentions 'explicitly addressed page' implying a prerequisite, but does not provide detailed when-to-use/when-not-to-use guidance relative to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close one explicitly addressed session and release all of its pages and isolated browser context. Close each role/account session when its workflow is complete.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| session | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint, idempotentHint), the description adds that closing a session releases all of its pages and isolated browser context, which is a useful behavioral detail. This enriches the agent's understanding without contradicting the provided hints.
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—two short sentences that pack in the action, its effect, and a usage tip. No word is wasted, and the most critical information appears first.
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 single-parameter tool with clear semantics and adequate annotations, the description covers the necessary aspects: what it does, what gets released, and when to use it. The presence of an output schema ensures return values are documented elsewhere, so the description need not address them.
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 description does not explain the sessionId parameter in detail; it only refers to an 'explicitly addressed session.' With 0% schema description coverage, more parameter-level guidance would have been helpful, though the tool name and parameter name are intuitive.
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 uses a specific verb 'close' with a clear resource 'explicitly addressed session' and explains the effect of releasing all pages and isolated browser context. It distinguishes itself from siblings like browser_page_close by focusing on the session-level scope.
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 instruction 'Close each role/account session when its workflow is complete' provides direct guidance on when to call this tool. While it doesn't name specific alternatives, the context makes the use case clear, and the per-session scope is explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new isolated browser session with its own cookies, storage, pages, and optional validated contextSettings (viewport, scale, locale, timezone, color scheme, reduced motion, user agent, geolocation, and explicit origin-scoped geolocation grants). Only the geolocation permission is supported; each grant must name one absolute HTTP(S) origin, never a wildcard. Create a separate session whenever a task involves a different user, account, role, authentication state, device profile, accessibility preference, permission profile, or independent parallel workflow; never reuse one session for identities or context settings that must remain isolated. The response directly returns both sessionId and the deterministic initial pageId plus normalized effective settings. Pass stateId only to restore previously saved browser state.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| stateId | No | ||
| metadata | No | ||
| contextSettings | No |
| Name | Required | Description |
|---|---|---|
| session | Yes | |
| initialPage | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=false and destructiveHint=false, so the mutating nature is clear. The description adds valuable behavior: sessions have isolated cookies/storage/pages, contextSettings are validated, geolocation is the only supported permission, and the response returns sessionId, initial pageId, and normalized effective settings. It could mention lifecycle/cleanup implications, but overall it gives meaningful transparency beyond the structured fields.
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 dense but well-organized, with the core action and key behavior front-loaded. Every sentence adds value, particularly around isolation, permissions, and return values. It is slightly long due to the contextSettings enumeration and redundancy with the schema, but no sentence is wasted.
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 with nested schema, zero schema descriptions, and many siblings, this description is comprehensive. It explains the session-creation semantics, isolation requirements, permission constraints, supported settings, restoration via stateId, and the deterministic initial pageId in the response. It is complete enough for an agent to select and invoke the tool correctly.
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 0%, so the description must compensate. It names the contextSettings fields in prose (viewport, scale, locale, timezone, color scheme, reduced motion, user agent, geolocation) and explains stateId's restore purpose. However, it does not explain the 'name' or 'metadata' parameters, and the mapping between 'scale' and deviceScaleFactor is not explicit. Still, it covers the critical parameter semantics well.
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 states a specific verb and resource: 'Create a new isolated browser session with its own cookies, storage, pages, and optional validated contextSettings.' It clearly distinguishes the tool from siblings like browser_session_get/list/close and browser_page_create by emphasizing isolation and session creation. This is unambiguous and context-rich.
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 gives explicit when-to-use guidance: 'Create a separate session whenever a task involves a different user, account, role, authentication state, device profile, accessibility preference, permission profile, or independent parallel workflow.' It also states a clear exclusion: 'never reuse one session for identities or context settings that must remain isolated,' plus the special-case use of stateId for restoring saved state. This is strong usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect one explicitly addressed browser session. Session names and metadata are workflow labels, not internal AI agents or owners.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| session | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so no contradiction. The description adds a clarifying note about session names being workflow labels rather than internal agents, which is useful context but not behavioral detail beyond what annotations cover. It does not describe output or side effects, but those are trivial for a read-only tool.
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 two sentences with no fluff. The first sentence states the core purpose, and the second adds a semantic clarification. Each sentence earns its place, and it is well-structured.
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 tool is simple with one parameter and an output schema that likely defines return format. The description fails to provide guidance on obtaining sessionId or connections to other session tools, but given low complexity and existing output schema, it is not critically incomplete. However, it could mention using browser_session_list to discover valid IDs.
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?
With schema description coverage at 0%, the description must compensate for the undocumented sessionId parameter. It only indicates 'explicitly addressed' without explaining what sessionId is, its format, or how to obtain it. This adds minimal meaning beyond the parameter name.
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 states specifically that the tool inspects one explicitly addressed browser session, with the verb 'Inspect' and a clear resource. It distinguishes from sibling tools like browser_session_list (which lists all) and create/close tools by emphasizing 'explicitly addressed'.
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 explicit guidance on when to use this tool versus alternatives. It does not mention browser_session_list for finding session IDs or any prerequisites. The 'explicitly addressed' phrase implies an ID is needed but does not direct the agent on how to obtain it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every browser session with its explicit sessionId, lifecycle status, name, and neutral workflow metadata. Use this to recover the correct session for each role/account; there is no global active session.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| sessions | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds behavioral context beyond annotations: it lists all sessions, specifies the fields returned, and reveals the important fact that there is no global active session. This adds value without contradiction.
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 two sentences, front-loaded with the core action and output, and then provides targeted usage context. Every word earns its place with no unnecessary elaboration.
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 low complexity (no params, read-only), the description fully covers purpose, usage, and a key system nuance. The output schema exists, so return value details need not be explained. The mention of 'neutral workflow metadata' is slightly vague but the overall context is 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 tool has zero parameters, so the baseline is 4 as per guidelines. The description correctly adds no parameter details since none exist, and the schema is fully covered with no parameters to document.
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 ('List') and resource ('browser sessions'), and specifies exactly what is returned: sessionId, lifecycle status, name, and workflow metadata. It distinguishes itself from siblings like browser_session_get by emphasizing 'every' session and the lack of a global active 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?
It explicitly instructs to use this tool to recover the correct session for roles/accounts, and highlights that there is no global active session. However, it does not explicitly name alternatives like browser_session_get for when a specific sessionId is already known, so it lacks explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect a bounded accessibility-oriented snapshot of one explicitly addressed page, optionally scoped by a locator including a bounded semantic iframe chain. BrowserMesh rejects oversized DOM sources before native ARIA serialization. Use interactiveOnly to retain interactive nodes with ancestor context and maxChildren to limit every node after filtering. A nextCursor continues the immutable captured serialization without rereading a changed DOM; cursors are page-scoped, expire after 30 seconds, and become stale on navigation or close. Semantic scope, depth, boxes, character/byte bounds, omissions, and truncation are explicit; partial content is aria-yaml-fragment. Non-empty password-input values are redacted before content crosses MCP. Optional 30-second element refs are separate short-lived action conveniences.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | No | ||
| cursor | No | ||
| pageId | Yes | ||
| maxRefs | No | ||
| maxBytes | No | ||
| maxChars | No | ||
| maxDepth | No | ||
| sessionId | Yes | ||
| timeoutMs | No | ||
| includeRefs | No | ||
| maxChildren | No | ||
| interactiveOnly | No | ||
| includeBoundingBoxes | No |
| Name | Required | Description |
|---|---|---|
| refs | Yes | |
| pageId | Yes | |
| partial | Yes | |
| snapshot | Yes | |
| omissions | Yes | |
| sessionId | Yes | |
| pagination | Yes | |
| truncation | Yes | |
| operationId | Yes | |
| appliedBounds | Yes | |
| contentFormat | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnly, idempotent), the description discloses many behaviors: rejection of oversized DOM, cursor expiration and staleness, password redaction, partial content as aria-yaml-fragment, and separate short-lived element refs. These add rich context not present in annotations and align with them.
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 dense but well-structured, front-loading the purpose first, then constraints and parameter-specific behaviors. Each sentence contributes unique information, though it is longer than necessary and could be more succinct while preserving 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?
Given the complexity and richness of the schema (13 parameters) and the presence of an output schema, the description covers many operational aspects: cursor semantics, truncation, redaction, and ref limitations. However, it still does not fully explain all parameter interactions or the exact output format, leaving some gaps.
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 0%, so the description must compensate for parameter explanations. It mentions interactiveOnly, maxChildren, nextCursor, and refs, but omits many parameters like maxDepth, maxBytes, maxChars, includeBoundingBoxes, and scope details. The vague statement 'Semantic scope, depth, boxes...' does not suffice for a 13-parameter tool.
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 inspects a bounded accessibility-oriented snapshot of one explicitly addressed page, with options for scoping via a locator and iframe chain. It uses specific verbs and resources ('inspect', 'accessibility-oriented snapshot') and distinguishes from sibling tools like browser_observe by emphasizing accessibility and boundedness.
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 clear context that this is for accessibility-oriented inspection, and mentions parameter usage like interactiveOnly and maxChildren. However, it does not explicitly state when to use this tool over alternatives (e.g., browser_observe) or list exclusion criteria — only implicit contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List logical saved-state IDs available for optional restoration when creating a new isolated session; state contents and secrets are not returned.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| states | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses a key behavioral trait beyond the annotations: 'state contents and secrets are not returned'. This prevents an agent from assuming that listing states returns full state data. Combined with the readOnlyHint, idempotentHint, and destructiveHint annotations, the tool's behavior is transparent.
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, well-structured sentence. It front-loads the action and resource, then adds the scope and a crucial negative detail without unnecessary words.
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 zero-parameter listing tool with strong annotations and an output schema, the description is complete. It clarifies what is returned (IDs only) and what is not returned (contents/secrets), leaving no major gaps for an agent selecting or invoking the 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 tool has zero parameters and an empty input schema, so there is no parameter semantics to explain. The baseline for no parameters is 4; the description correctly implies no inputs are needed.
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 starts with the specific verb 'List' and identifies the resource as 'logical saved-state IDs', while also clarifying they are 'available for optional restoration when creating a new isolated session'. This clearly distinguishes it from sibling tools like browser_session_list or browser_state_save.
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 gives clear context: this tool is used to enumerate saved-state IDs for optional restoration during isolated session creation. It does not explicitly state when not to use it or name alternatives, but the use case is specific enough to guide an agent effectively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete persisted browser state by its safe logical stateId when it should no longer be restorable. This does not close or alter currently live sessions.
| Name | Required | Description | Default |
|---|---|---|---|
| stateId | Yes |
| Name | Required | Description |
|---|---|---|
| removed | Yes | |
| stateId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, so the description does not need to repeat that. The description adds a key behavioral nuance: it clarifies that removing state does not close or alter live sessions, which is valuable beyond the annotation. However, it does not detail what happens to the state data or if any confirmation is needed, but given the annotation coverage, this is adequate. No contradiction with annotations.
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 two concise sentences, front-loaded with the action ('Delete persisted browser state') and includes a crucial clarification. Every word earns its place; no redundancy or fluff. Efficient and well-structured.
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 complexity is low (single parameter, clear destructive intent), the description provides the essential context: what it deletes and that it does not affect live sessions. The output schema exists, so return details are not needed. However, the lack of parameter semantics (as noted) leaves a gap for an agent to correctly construct the stateId, and the description could have mentioned the need to list states or save state to get valid stateIds.
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 only one parameter (stateId) with basic type and length constraints, and schema description coverage is 0%. The description mentions 'safe logical stateId' but does not explain what 'safe' means or how to obtain a valid stateId, nor does it clarify if it is a UUID or an opaque identifier. With no parameter documentation in the schema, the description fails to provide sufficient semantics beyond listing the parameter name.
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 (delete persisted browser state) and the resource (by stateId), and distinguishes it from related state operations like browser_state_save and browser_state_list. However, it could have been more explicit about when to remove state versus other lifecycle operations, but the core purpose is clear and unambiguous.
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 some usage context by stating the condition for deletion ('when it should no longer be restorable'), which implies it is for cleanup of obsolete states. It also clarifies that it does not affect live sessions, which is a useful exclusion. However, it does not explicitly mention alternative tools for managing sessions or when NOT to use this tool, leaving the usage guidance somewhat implicit rather than fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Save cookies and supported storage from one explicitly addressed session under a safe logical stateId. Use this only when a later new isolated session should restore that authentication state.
| Name | Required | Description | Default |
|---|---|---|---|
| stateId | Yes | ||
| sessionId | Yes |
| Name | Required | Description |
|---|---|---|
| state | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims the stateId is 'safe,' directly contradicting the annotations' destructiveHint=true. It does not disclose what destructive action might occur (e.g., overwriting existing state, clearing storage). This is a clear annotation contradiction and a significant transparency 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?
The description is two sentences, immediately states the core action, and includes the critical usage condition. Every word contributes value with no redundancy.
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 ideal usage, but omits important context such as what 'supported storage' includes, behavior when a stateId already exists, error conditions, and the destructive implications flagged by annotations. It is adequate but leaves gaps for a complex save/restore operation.
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?
With schema description coverage at 0%, the description adds valuable meaning by referring to 'explicitly addressed session' (mapping to sessionId) and 'logical stateId' (mapping to stateId). However, it does not provide detailed syntax, constraints, or potential values beyond what the schema's type and length limits already offer.
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 uses the specific verb 'Save' and clearly states the resource: 'cookies and supported storage from one explicitly addressed session under a safe logical stateId.' This distinguishes it from sibling tools like browser_state_list and browser_state_remove, which perform different actions.
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 explicit usage context: 'Use this only when a later new isolated session should restore that authentication state.' This clearly indicates when the tool should be used, and the 'only when' phrasing implies when not to use it, though no alternative tools are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Ensure a checkbox located semantically or by CSS is unchecked on one explicitly addressed page. The operation is idempotent, bounded by timeoutMs, and isolated to the supplied session.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | ||
| pageId | Yes | ||
| locator | No | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| completed | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds behavioral details beyond annotations: idempotency (already in annotations), timeout bounding, and session isolation. Also notes that the locator can be semantic or CSS, giving insight into how the tool locates elements.
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, two sentences, and front-loaded with the core action. No redundant information or fluff.
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?
Provides sufficient context for a simple action but does not elaborate on the complex locator schema, potential failure modes, or prerequisites. Given the complexity of the input schema, it could be more explanatory, but it is adequate for an experienced user.
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 0% and the description does not explain the meaning of key parameters (ref, pageId, locator, sessionId) nor the locator structure. It only indirectly hints at timeoutMs and sessionId. This falls short of compensating for the lack of parameter explanations.
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 (uncheck a checkbox) and the resource (checkbox), with explicit mention of locator strategies (semantic or CSS) and page targeting. It distinguishes from sibling tools like browser_check.
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?
Clearly implies when to use (to uncheck a checkbox) and provides operational context (idempotent, bounded by timeout, session-isolated). However, it does not explicitly contrast with alternatives like browser_check or mention when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read visible text from a semantic or CSS locator on one explicitly addressed page. A locator may select the top document or a bounded outer-to-inner semantic iframe chain; the lookup remains confined to that page and session.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| locator | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| text | Yes | |
| pageId | Yes | |
| sessionId | Yes | |
| truncation | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, establishing the safety profile. The description adds that the tool operates on visible text and remains within a page/session, providing additional scoping context beyond the annotations. No contradictions.
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 two sentences, front-loaded with the action ('Read visible text') and packs essential details (locator types, iframe chain, page/session confinement) without waste. Efficient and well-structured.
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 complexity of the locator (with iframe chains) and the presence of an output schema, the description covers the core purpose and scoping adequately. It does not explain return values, but that's covered by the output schema. It is sufficiently complete for a read-only tool with safety annotations, though it could mention timeout behavior or edge cases.
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 0%, so the description must carry the burden. It explains the locator concept ('semantic or CSS locator' and 'iframe chain'), adding meaning for the complex locator parameter. However, it does not explicitly address sessionId, pageId, or timeoutMs, leaving some parameters only schema-defined. The value added is partial, not comprehensive.
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 reads visible text from a semantic or CSS locator on a specific page. It distinguishes itself from sibling tools like browser_snapshot or browser_get_title by specifying the locator-based extraction and page confinement.
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 explicitly identifies the scope: 'one explicitly addressed page' and 'the lookup remains confined to that page and session.' This gives clear context for when to use the tool, but it does not name alternatives or state when not to use it, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Wait for one deterministic passive condition on an explicitly addressed page: an exact/safe-glob URL, domcontentloaded/load state, locator state (optionally through a bounded semantic iframe chain), or case-sensitive top-document text presence/absence. The wait occupies that session queue, is bounded by timeoutMs, and must not depend on a later action queued in the same session; use browser_action_and_wait for action-triggered events.
| Name | Required | Description | Default |
|---|---|---|---|
| pageId | Yes | ||
| condition | Yes | ||
| sessionId | Yes | ||
| timeoutMs | No |
| Name | Required | Description |
|---|---|---|
| pageId | Yes | |
| satisfied | Yes | |
| sessionId | Yes | |
| operationId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly, openWorld, and idempotent behavior, so the description's burden is lower, but it still adds valuable non-obvious behavioral details: the wait occupies the session queue, is bounded by timeoutMs, and must not depend on future queued actions. No contradiction with annotations exists.
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?
A single dense, information-rich sentence with a clear colon-delimited list of condition types. Every clause adds meaningful guidance: scope, condition kinds, queue behavior, timeout, and the alternative tool. No filler or redundancy.
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 complex tool with four parameters and zero schema description coverage, the description is remarkably complete: it defines the wait domain, frame targeting, condition taxonomy, timeout semantics, queue restrictions, and relationship to sibling tools. The output schema covers return details, so no further explanation is needed.
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 0%, so the description carries the full burden. It explains the meaning of condition categories, timeoutMs, 'safe-glob', iframe chains, and text case-sensitivity, going well beyond raw schema. It does not exhaustively narrate every nested locator strategy, but the schema enums cover those details.
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 uses a specific verb ('Wait') and enumerates the exact supported condition types: exact/safe-glob URL, load states, locator state with optional iframe chain, and text presence/absence. It also distinguishes itself from the sibling browser_action_and_wait by clarifying this is for deterministic passive conditions only.
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?
Explicitly states when to use versus when not to use: 'must not depend on a later action queued in the same session; use browser_action_and_wait for action-triggered events.' It also mentions the session queue and timeout binding, giving clear operational context.
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. Dates show when Glama detected each change.
v0.2.1browser_action_and_wait9 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared3"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared4"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "anyOf": [
+ {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared3"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared4"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ {
+ "properties": {
+ "ref": {
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "ref"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared2": {
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "exact",
+ "type": "string"
+ },
+ "value": {
+ "maxLength": 2048,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "glob",
+ "type": "string"
+ },
+ "value": {
+ "maxLength": 2048,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared3": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared4": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / action / anyOfRemoved value: -[
- {
- "properties": {
- "kind": {
- "const": "click",
- "type": "string"
- },
- "target": {
- "anyOf": [
- {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- {
- "properties": {
- "ref": {
- "pattern": "^@e[a-f0-9]{32}$",
- "type": "string"
- }
- },
- "required": [
- "ref"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "target"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "click",
- "type": "string"
- },
- "locator": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "locator"
- ],
- "type": "object"
- },
- {
- "properties": {
- "key": {
- "maxLength": 64,
- "minLength": 1,
- "type": "string"
- },
- "kind": {
- "const": "press",
- "type": "string"
- },
- "target": {
- "anyOf": [
- {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- {
- "properties": {
- "ref": {
- "pattern": "^@e[a-f0-9]{32}$",
- "type": "string"
- }
- },
- "required": [
- "ref"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "target",
- "key"
- ],
- "type": "object"
- },
- {
- "properties": {
- "key": {
- "maxLength": 64,
- "minLength": 1,
- "type": "string"
- },
- "kind": {
- "const": "press",
- "type": "string"
- },
- "locator": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "locator",
- "key"
- ],
- "type": "object"
- }
-]Input schema / properties / action / oneOfAdded value: +[
+ {
+ "properties": {
+ "kind": {
+ "const": "click",
+ "type": "string"
+ },
+ "target": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "kind",
+ "target"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "key": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "kind": {
+ "const": "press",
+ "type": "string"
+ },
+ "target": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "kind",
+ "target",
+ "key"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / wait / oneOfPrevious value: -[
- {
- "properties": {
- "kind": {
- "const": "navigation",
- "type": "string"
- },
- "loadState": {
- "enum": [
- "domcontentloaded",
- "load"
- ],
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "response",
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "method": {
- "pattern": "^[A-Z]{1,16}$",
- "type": "string"
- },
- "status": {
- "maximum": 599,
- "minimum": 100,
- "type": "integer"
- }
- },
- "required": [
- "kind",
- "matcher"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "popup",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "action": {
- "enum": [
- "accept",
- "dismiss"
- ],
- "type": "string"
- },
- "dialogType": {
- "enum": [
- "alert",
- "beforeunload",
- "confirm",
- "prompt"
- ],
- "type": "string"
- },
- "kind": {
- "const": "dialog",
- "type": "string"
- },
- "promptText": {
- "maxLength": 2000,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "dialogType",
- "action"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "kind": {
+ "const": "navigation",
+ "type": "string"
+ },
+ "loadState": {
+ "enum": [
+ "domcontentloaded",
+ "load"
+ ],
+ "type": "string"
+ },
+ "matcher": {
+ "$ref": "#/$defs/shared2"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "response",
+ "type": "string"
+ },
+ "matcher": {
+ "$ref": "#/$defs/shared2"
+ },
+ "method": {
+ "pattern": "^[A-Z]{1,16}$",
+ "type": "string"
+ },
+ "status": {
+ "maximum": 599,
+ "minimum": 100,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "kind",
+ "matcher"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "popup",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "action": {
+ "enum": [
+ "accept",
+ "dismiss"
+ ],
+ "type": "string"
+ },
+ "dialogType": {
+ "enum": [
+ "alert",
+ "beforeunload",
+ "confirm",
+ "prompt"
+ ],
+ "type": "string"
+ },
+ "kind": {
+ "const": "dialog",
+ "type": "string"
+ },
+ "promptText": {
+ "maxLength": 2000,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "dialogType",
+ "action"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / actionRemoved value: -{
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "click",
- "type": "string"
- },
- "target": {
- "anyOf": [
- {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "ref": {
- "pattern": "^@e[a-f0-9]{32}$",
- "type": "string"
- }
- },
- "required": [
- "ref"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "target"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "key": {
- "type": "string"
- },
- "kind": {
- "const": "press",
- "type": "string"
- },
- "target": {
- "anyOf": [
- {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "ref": {
- "pattern": "^@e[a-f0-9]{32}$",
- "type": "string"
- }
- },
- "required": [
- "ref"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "target",
- "key"
- ],
- "type": "object"
- }
- ]
-}Output schema / properties / waitRemoved value: -{
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "navigation",
- "type": "string"
- },
- "loadState": {
- "enum": [
- "domcontentloaded",
- "load"
- ],
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "response",
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "method": {
- "type": "string"
- },
- "status": {
- "maximum": 9007199254740991,
- "minimum": -9007199254740991,
- "type": "integer"
- }
- },
- "required": [
- "kind",
- "matcher"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "popup",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "action": {
- "enum": [
- "accept",
- "dismiss"
- ],
- "type": "string"
- },
- "dialogType": {
- "enum": [
- "alert",
- "beforeunload",
- "confirm",
- "prompt"
- ],
- "type": "string"
- },
- "kind": {
- "const": "dialog",
- "type": "string"
- },
- "promptText": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "dialogType",
- "action"
- ],
- "type": "object"
- }
- ]
-}Output schema / requiredPrevious value: -[
- "operationId",
- "sessionId",
- "pageId",
- "action",
- "wait",
- "event"
-]New value: +[
+ "operationId",
+ "sessionId",
+ "pageId",
+ "event"
+]browser_back2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_check4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_click4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_console_listbrowser_double_click4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_drag_and_drop7 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared2"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared3"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared2"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared3"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared2": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared3": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / source / $refAdded value: +"#/$defs/shared1"Input schema / properties / source / oneOfRemoved value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]Input schema / properties / target / $refAdded value: +"#/$defs/shared1"Input schema / properties / target / oneOfRemoved value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_failed_requests_listbrowser_fill4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_focus4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_forward2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_get_title2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_get_url2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_hover4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_navigate2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_network_listbrowser_observebrowser_page_close2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_page_create2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_page_errors_listbrowser_page_list2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_press4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_reload2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_runtime_info78 fields changedOutput schema / $defsAdded value: +{
+ "shared0": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ }
+}Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / defaultTimeoutMs / $refAdded value: +"#/$defs/shared0"Output schema / properties / defaultTimeoutMs / exclusiveMinimumRemoved value: -0Output schema / properties / defaultTimeoutMs / maximumRemoved value: -9007199254740991Output schema / properties / defaultTimeoutMs / typeRemoved value: -"integer"Output schema / properties / maxPagesPerSession / $refAdded value: +"#/$defs/shared0"Output schema / properties / maxPagesPerSession / exclusiveMinimumRemoved value: -0Output schema / properties / maxPagesPerSession / maximumRemoved value: -9007199254740991Output schema / properties / maxPagesPerSession / typeRemoved value: -"integer"Output schema / properties / maxSessions / $refAdded value: +"#/$defs/shared0"Output schema / properties / maxSessions / exclusiveMinimumRemoved value: -0Output schema / properties / maxSessions / maximumRemoved value: -9007199254740991Output schema / properties / maxSessions / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / persistence / properties / maxStateBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / persistence / properties / maxStateBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / persistence / properties / maxStateBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / persistence / properties / maxStateBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / persistence / properties / maxStates / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / persistence / properties / maxStates / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / persistence / properties / maxStates / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / persistence / properties / maxStates / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / persistence / properties / maxTotalBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / persistence / properties / maxTotalBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / persistence / properties / maxTotalBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / persistence / properties / maxTotalBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / screenshot / properties / maxBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / screenshot / properties / maxBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / screenshot / properties / maxBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / screenshot / properties / maxBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / screenshot / properties / maxDimensionPixels / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / screenshot / properties / maxDimensionPixels / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / screenshot / properties / maxDimensionPixels / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / screenshot / properties / maxDimensionPixels / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / screenshot / properties / maxPixels / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / screenshot / properties / maxPixels / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / screenshot / properties / maxPixels / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / screenshot / properties / maxPixels / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataEntries / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataEntries / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataEntries / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataEntries / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyChars / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyChars / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataKeyChars / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueChars / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueChars / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxMetadataValueChars / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxNameBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxNameBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxNameBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxNameBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / session / properties / maxNameChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / session / properties / maxNameChars / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / session / properties / maxNameChars / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / session / properties / maxNameChars / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / visibleText / properties / maxBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / visibleText / properties / maxBytes / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / visibleText / properties / maxBytes / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / visibleText / properties / maxBytes / typeRemoved value: -"integer"Output schema / properties / resourceLimits / properties / visibleText / properties / maxChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / resourceLimits / properties / visibleText / properties / maxChars / exclusiveMinimumRemoved value: -0Output schema / properties / resourceLimits / properties / visibleText / properties / maxChars / maximumRemoved value: -9007199254740991Output schema / properties / resourceLimits / properties / visibleText / properties / maxChars / typeRemoved value: -"integer"browser_screenshot17 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / capture / oneOfPrevious value: -[
- {
- "properties": {
- "kind": {
- "const": "viewport",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "fullPage",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "element",
- "type": "string"
- },
- "locator": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "locator"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "kind": {
+ "const": "viewport",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "fullPage",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "element",
+ "type": "string"
+ },
+ "locator": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ }
+ },
+ "required": [
+ "kind",
+ "locator"
+ ],
+ "type": "object"
+ }
+]Output schema / $defsAdded value: +{
+ "shared0": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ }
+}Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / bytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / bytes / exclusiveMinimumRemoved value: -0Output schema / properties / bytes / maximumRemoved value: -9007199254740991Output schema / properties / bytes / typeRemoved value: -"integer"Output schema / properties / height / $refAdded value: +"#/$defs/shared0"Output schema / properties / height / exclusiveMinimumRemoved value: -0Output schema / properties / height / maximumRemoved value: -9007199254740991Output schema / properties / height / typeRemoved value: -"integer"Output schema / properties / width / $refAdded value: +"#/$defs/shared0"Output schema / properties / width / exclusiveMinimumRemoved value: -0Output schema / properties / width / maximumRemoved value: -9007199254740991Output schema / properties / width / typeRemoved value: -"integer"browser_scroll2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_scroll_into_view4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_select_option4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_session_close2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_session_create2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_session_get2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_session_list1 field changedOutput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_snapshot48 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / scope / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $defsAdded value: +{
+ "shared0": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "exact": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared3"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared4"
+ },
+ "value": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "shared2": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "shared3": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared4": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / appliedBounds / properties / maxBytes / $refAdded value: +"#/$defs/shared2"Output schema / properties / appliedBounds / properties / maxBytes / exclusiveMinimumRemoved value: -0Output schema / properties / appliedBounds / properties / maxBytes / maximumRemoved value: -9007199254740991Output schema / properties / appliedBounds / properties / maxBytes / typeRemoved value: -"integer"Output schema / properties / appliedBounds / properties / maxChars / $refAdded value: +"#/$defs/shared2"Output schema / properties / appliedBounds / properties / maxChars / exclusiveMinimumRemoved value: -0Output schema / properties / appliedBounds / properties / maxChars / maximumRemoved value: -9007199254740991Output schema / properties / appliedBounds / properties / maxChars / typeRemoved value: -"integer"Output schema / properties / appliedBounds / properties / maxChildren / anyOfPrevious value: -[
- {
- "exclusiveMinimum": 0,
- "maximum": 9007199254740991,
- "type": "integer"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "$ref": "#/$defs/shared2"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / appliedBounds / properties / maxDepth / anyOfPrevious value: -[
- {
- "maximum": 9007199254740991,
- "minimum": 0,
- "type": "integer"
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "$ref": "#/$defs/shared1"
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / appliedBounds / properties / maxRefs / $refAdded value: +"#/$defs/shared2"Output schema / properties / appliedBounds / properties / maxRefs / exclusiveMinimumRemoved value: -0Output schema / properties / appliedBounds / properties / maxRefs / maximumRemoved value: -9007199254740991Output schema / properties / appliedBounds / properties / maxRefs / typeRemoved value: -"integer"Output schema / properties / appliedBounds / properties / scope / anyOfPrevious value: -[
- {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- {
- "type": "null"
- }
-]New value: +[
+ {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "exact": {
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared3"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared4"
+ },
+ "value": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ {
+ "type": "null"
+ }
+]Output schema / properties / omissions / properties / maxChildrenNodes / $refAdded value: +"#/$defs/shared1"Output schema / properties / omissions / properties / maxChildrenNodes / maximumRemoved value: -9007199254740991Output schema / properties / omissions / properties / maxChildrenNodes / minimumRemoved value: -0Output schema / properties / omissions / properties / maxChildrenNodes / typeRemoved value: -"integer"Output schema / properties / omissions / properties / nonInteractiveNodes / $refAdded value: +"#/$defs/shared1"Output schema / properties / omissions / properties / nonInteractiveNodes / maximumRemoved value: -9007199254740991Output schema / properties / omissions / properties / nonInteractiveNodes / minimumRemoved value: -0Output schema / properties / omissions / properties / nonInteractiveNodes / typeRemoved value: -"integer"Output schema / properties / pagination / properties / offsetChars / $refAdded value: +"#/$defs/shared1"Output schema / properties / pagination / properties / offsetChars / maximumRemoved value: -9007199254740991Output schema / properties / pagination / properties / offsetChars / minimumRemoved value: -0Output schema / properties / pagination / properties / offsetChars / typeRemoved value: -"integer"Output schema / properties / truncation / properties / originalBytes / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / originalBytes / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / originalBytes / minimumRemoved value: -0Output schema / properties / truncation / properties / originalBytes / typeRemoved value: -"integer"Output schema / properties / truncation / properties / originalChars / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / originalChars / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / originalChars / minimumRemoved value: -0Output schema / properties / truncation / properties / originalChars / typeRemoved value: -"integer"Output schema / properties / truncation / properties / returnedBytes / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / returnedBytes / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / returnedBytes / minimumRemoved value: -0Output schema / properties / truncation / properties / returnedBytes / typeRemoved value: -"integer"Output schema / properties / truncation / properties / returnedChars / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / returnedChars / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / returnedChars / minimumRemoved value: -0Output schema / properties / truncation / properties / returnedChars / typeRemoved value: -"integer"browser_state_list1 field changedOutput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_state_remove2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_state_save2 fields changedInput schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_uncheck4 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"browser_visible_text29 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / $defsAdded value: +{
+ "shared0": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "shared1": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ }
+}Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / truncation / properties / maxBytes / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / maxBytes / exclusiveMinimumRemoved value: -0Output schema / properties / truncation / properties / maxBytes / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / maxBytes / typeRemoved value: -"integer"Output schema / properties / truncation / properties / maxChars / $refAdded value: +"#/$defs/shared1"Output schema / properties / truncation / properties / maxChars / exclusiveMinimumRemoved value: -0Output schema / properties / truncation / properties / maxChars / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / maxChars / typeRemoved value: -"integer"Output schema / properties / truncation / properties / originalBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / truncation / properties / originalBytes / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / originalBytes / minimumRemoved value: -0Output schema / properties / truncation / properties / originalBytes / typeRemoved value: -"integer"Output schema / properties / truncation / properties / originalChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / truncation / properties / originalChars / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / originalChars / minimumRemoved value: -0Output schema / properties / truncation / properties / originalChars / typeRemoved value: -"integer"Output schema / properties / truncation / properties / returnedBytes / $refAdded value: +"#/$defs/shared0"Output schema / properties / truncation / properties / returnedBytes / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / returnedBytes / minimumRemoved value: -0Output schema / properties / truncation / properties / returnedBytes / typeRemoved value: -"integer"Output schema / properties / truncation / properties / returnedChars / $refAdded value: +"#/$defs/shared0"Output schema / properties / truncation / properties / returnedChars / maximumRemoved value: -9007199254740991Output schema / properties / truncation / properties / returnedChars / minimumRemoved value: -0Output schema / properties / truncation / properties / returnedChars / typeRemoved value: -"integer"browser_wait7 fields changedInput schema / $defsAdded value: +{
+ "shared0": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "shared1": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ },
+ "shared2": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ }
+}Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Input schema / properties / condition / oneOfPrevious value: -[
- {
- "properties": {
- "kind": {
- "const": "url",
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "maxLength": 2048,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "matcher"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "load",
- "type": "string"
- },
- "state": {
- "enum": [
- "domcontentloaded",
- "load"
- ],
- "type": "string"
- }
- },
- "required": [
- "kind",
- "state"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "locator",
- "type": "string"
- },
- "locator": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "frame": {
- "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
- "oneOf": [
- {
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "state": {
- "enum": [
- "visible",
- "hidden",
- "attached",
- "detached",
- "enabled",
- "disabled"
- ],
- "type": "string"
- }
- },
- "required": [
- "kind",
- "locator",
- "state"
- ],
- "type": "object"
- },
- {
- "properties": {
- "kind": {
- "const": "text",
- "type": "string"
- },
- "state": {
- "enum": [
- "present",
- "absent"
- ],
- "type": "string"
- },
- "text": {
- "maxLength": 2000,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "kind",
- "text",
- "state"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "kind": {
+ "const": "url",
+ "type": "string"
+ },
+ "matcher": {
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "exact",
+ "type": "string"
+ },
+ "value": {
+ "maxLength": 2048,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "glob",
+ "type": "string"
+ },
+ "value": {
+ "maxLength": 2048,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ }
+ },
+ "required": [
+ "kind",
+ "matcher"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "load",
+ "type": "string"
+ },
+ "state": {
+ "enum": [
+ "domcontentloaded",
+ "load"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "state"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "locator",
+ "type": "string"
+ },
+ "locator": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "$ref": "#/$defs/shared1"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "$ref": "#/$defs/shared0"
+ },
+ "strategy": {
+ "$ref": "#/$defs/shared2"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "state": {
+ "enum": [
+ "visible",
+ "hidden",
+ "attached",
+ "detached",
+ "enabled",
+ "disabled"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "locator",
+ "state"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "text",
+ "type": "string"
+ },
+ "state": {
+ "enum": [
+ "present",
+ "absent"
+ ],
+ "type": "string"
+ },
+ "text": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "text",
+ "state"
+ ],
+ "type": "object"
+ }
+]Output schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"Output schema / properties / conditionRemoved value: -{
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "url",
- "type": "string"
- },
- "matcher": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "exact",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "glob",
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "value"
- ],
- "type": "object"
- }
- ]
- }
- },
- "required": [
- "kind",
- "matcher"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "load",
- "type": "string"
- },
- "state": {
- "enum": [
- "domcontentloaded",
- "load"
- ],
- "type": "string"
- }
- },
- "required": [
- "kind",
- "state"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "locator",
- "type": "string"
- },
- "locator": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "frame": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "main",
- "type": "string"
- }
- },
- "required": [
- "kind"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "chain": {
- "items": {
- "oneOf": [
- {
- "additionalProperties": false,
- "properties": {
- "exact": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "maxItems": 5,
- "minItems": 1,
- "type": "array"
- },
- "kind": {
- "const": "iframe",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "chain"
- ],
- "type": "object"
- }
- ]
- },
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
- ]
- },
- "state": {
- "enum": [
- "visible",
- "hidden",
- "attached",
- "detached",
- "enabled",
- "disabled"
- ],
- "type": "string"
- }
- },
- "required": [
- "kind",
- "locator",
- "state"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "text",
- "type": "string"
- },
- "state": {
- "enum": [
- "present",
- "absent"
- ],
- "type": "string"
- },
- "text": {
- "type": "string"
- }
- },
- "required": [
- "kind",
- "text",
- "state"
- ],
- "type": "object"
- }
- ]
-}Output schema / properties / satisfiedAdded value: +{
+ "const": true,
+ "type": "boolean"
+}Output schema / requiredPrevious value: -[
- "operationId",
- "sessionId",
- "pageId",
- "condition"
-]New value: +[
+ "operationId",
+ "sessionId",
+ "pageId",
+ "satisfied"
+]v0.1.5browser_action_and_waitbrowser_back1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "url"
+ ],
+ "type": "object"
+}browser_checkbrowser_click4 fields changedInput schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / refAdded value: +{
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "sessionId",
- "pageId",
- "locator"
-]New value: +[
+ "sessionId",
+ "pageId"
+]Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "completed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "completed"
+ ],
+ "type": "object"
+}browser_console_listbrowser_double_clickbrowser_drag_and_dropbrowser_failed_requests_listbrowser_fill4 fields changedInput schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / refAdded value: +{
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "sessionId",
- "pageId",
- "locator",
- "value"
-]New value: +[
+ "sessionId",
+ "pageId",
+ "value"
+]Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "completed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "completed"
+ ],
+ "type": "object"
+}browser_focusbrowser_forward1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "url"
+ ],
+ "type": "object"
+}browser_get_title1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "title"
+ ],
+ "type": "object"
+}browser_get_url1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "url"
+ ],
+ "type": "object"
+}browser_hoverbrowser_navigate1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "url"
+ ],
+ "type": "object"
+}browser_network_listbrowser_page_close1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "closed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "closed"
+ ],
+ "type": "object"
+}browser_page_create1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "page": {
+ "additionalProperties": false,
+ "properties": {
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "isDefault": {
+ "type": "boolean"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "pageId",
+ "sessionId",
+ "createdAt",
+ "url",
+ "isDefault"
+ ],
+ "type": "object"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "page"
+ ],
+ "type": "object"
+}browser_page_errors_listbrowser_page_list1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pages": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "isDefault": {
+ "type": "boolean"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "pageId",
+ "sessionId",
+ "createdAt",
+ "url",
+ "isDefault"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pages"
+ ],
+ "type": "object"
+}browser_press4 fields changedInput schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / refAdded value: +{
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "sessionId",
- "pageId",
- "locator",
- "key"
-]New value: +[
+ "sessionId",
+ "pageId",
+ "key"
+]Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "completed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "completed"
+ ],
+ "type": "object"
+}browser_reload1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "url"
+ ],
+ "type": "object"
+}browser_runtime_infobrowser_screenshot2 fields changedInput schema / properties / captureAdded value: +{
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "viewport",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "fullPage",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "kind": {
+ "const": "element",
+ "type": "string"
+ },
+ "locator": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ }
+ },
+ "required": [
+ "kind",
+ "locator"
+ ],
+ "type": "object"
+ }
+ ]
+}Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "bytes": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "height": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "mimeType": {
+ "const": "image/png",
+ "type": "string"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "width": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "mimeType",
+ "width",
+ "height",
+ "bytes"
+ ],
+ "type": "object"
+}browser_scrollbrowser_scroll_into_viewbrowser_select_option4 fields changedInput schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / refAdded value: +{
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+}Input schema / requiredPrevious value: -[
- "sessionId",
- "pageId",
- "locator",
- "value"
-]New value: +[
+ "sessionId",
+ "pageId",
+ "value"
+]Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "completed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "completed"
+ ],
+ "type": "object"
+}browser_session_close1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "session": {
+ "additionalProperties": false,
+ "properties": {
+ "contextSettings": {
+ "additionalProperties": false,
+ "properties": {
+ "colorScheme": {
+ "enum": [
+ "light",
+ "dark",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "deviceScaleFactor": {
+ "maximum": 10,
+ "minimum": 0.1,
+ "type": "number"
+ },
+ "geolocation": {
+ "additionalProperties": false,
+ "properties": {
+ "accuracy": {
+ "maximum": 100000,
+ "minimum": 0,
+ "type": "number"
+ },
+ "latitude": {
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "longitude": {
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ }
+ },
+ "required": [
+ "latitude",
+ "longitude"
+ ],
+ "type": "object"
+ },
+ "locale": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permissions": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "origin": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permission": {
+ "const": "geolocation",
+ "type": "string"
+ }
+ },
+ "required": [
+ "permission",
+ "origin"
+ ],
+ "type": "object"
+ },
+ "maxItems": 100,
+ "type": "array"
+ },
+ "reducedMotion": {
+ "enum": [
+ "reduce",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "timezoneId": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "userAgent": {
+ "maxLength": 512,
+ "minLength": 1,
+ "type": "string"
+ },
+ "viewport": {
+ "additionalProperties": false,
+ "properties": {
+ "height": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "width": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "width",
+ "height"
+ ],
+ "type": "object"
+ }
+ },
+ "type": "object"
+ },
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "lastActivityAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "metadata": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "name": {
+ "type": "string"
+ },
+ "restoredFromStateId": {
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "status": {
+ "enum": [
+ "creating",
+ "ready",
+ "closing",
+ "closed",
+ "failed"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionId",
+ "status",
+ "createdAt",
+ "lastActivityAt",
+ "metadata",
+ "contextSettings"
+ ],
+ "type": "object"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "session"
+ ],
+ "type": "object"
+}browser_session_create5 fields changedInput schema / properties / contextSettingsAdded value: +{
+ "properties": {
+ "colorScheme": {
+ "enum": [
+ "light",
+ "dark",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "deviceScaleFactor": {
+ "maximum": 10,
+ "minimum": 0.1,
+ "type": "number"
+ },
+ "geolocation": {
+ "properties": {
+ "accuracy": {
+ "maximum": 100000,
+ "minimum": 0,
+ "type": "number"
+ },
+ "latitude": {
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "longitude": {
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ }
+ },
+ "required": [
+ "latitude",
+ "longitude"
+ ],
+ "type": "object"
+ },
+ "locale": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permissions": {
+ "items": {
+ "properties": {
+ "origin": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permission": {
+ "const": "geolocation",
+ "type": "string"
+ }
+ },
+ "required": [
+ "permission",
+ "origin"
+ ],
+ "type": "object"
+ },
+ "maxItems": 100,
+ "type": "array"
+ },
+ "reducedMotion": {
+ "enum": [
+ "reduce",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "timezoneId": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "userAgent": {
+ "maxLength": 512,
+ "minLength": 1,
+ "type": "string"
+ },
+ "viewport": {
+ "properties": {
+ "height": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "width": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "width",
+ "height"
+ ],
+ "type": "object"
+ }
+ },
+ "type": "object"
+}Input schema / properties / metadata / additionalProperties / maxLengthAdded value: +512Input schema / properties / metadata / propertyNames / maxLengthAdded value: +64Input schema / properties / metadata / propertyNames / minLengthAdded value: +1Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "initialPage": {
+ "additionalProperties": false,
+ "properties": {
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionId",
+ "pageId"
+ ],
+ "type": "object"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "session": {
+ "additionalProperties": false,
+ "properties": {
+ "contextSettings": {
+ "additionalProperties": false,
+ "properties": {
+ "colorScheme": {
+ "enum": [
+ "light",
+ "dark",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "deviceScaleFactor": {
+ "maximum": 10,
+ "minimum": 0.1,
+ "type": "number"
+ },
+ "geolocation": {
+ "additionalProperties": false,
+ "properties": {
+ "accuracy": {
+ "maximum": 100000,
+ "minimum": 0,
+ "type": "number"
+ },
+ "latitude": {
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "longitude": {
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ }
+ },
+ "required": [
+ "latitude",
+ "longitude"
+ ],
+ "type": "object"
+ },
+ "locale": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permissions": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "origin": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permission": {
+ "const": "geolocation",
+ "type": "string"
+ }
+ },
+ "required": [
+ "permission",
+ "origin"
+ ],
+ "type": "object"
+ },
+ "maxItems": 100,
+ "type": "array"
+ },
+ "reducedMotion": {
+ "enum": [
+ "reduce",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "timezoneId": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "userAgent": {
+ "maxLength": 512,
+ "minLength": 1,
+ "type": "string"
+ },
+ "viewport": {
+ "additionalProperties": false,
+ "properties": {
+ "height": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "width": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "width",
+ "height"
+ ],
+ "type": "object"
+ }
+ },
+ "type": "object"
+ },
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "lastActivityAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "metadata": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "name": {
+ "type": "string"
+ },
+ "restoredFromStateId": {
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "status": {
+ "enum": [
+ "creating",
+ "ready",
+ "closing",
+ "closed",
+ "failed"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionId",
+ "status",
+ "createdAt",
+ "lastActivityAt",
+ "metadata",
+ "contextSettings"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "operationId",
+ "session",
+ "initialPage"
+ ],
+ "type": "object"
+}browser_session_get1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "session": {
+ "additionalProperties": false,
+ "properties": {
+ "contextSettings": {
+ "additionalProperties": false,
+ "properties": {
+ "colorScheme": {
+ "enum": [
+ "light",
+ "dark",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "deviceScaleFactor": {
+ "maximum": 10,
+ "minimum": 0.1,
+ "type": "number"
+ },
+ "geolocation": {
+ "additionalProperties": false,
+ "properties": {
+ "accuracy": {
+ "maximum": 100000,
+ "minimum": 0,
+ "type": "number"
+ },
+ "latitude": {
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "longitude": {
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ }
+ },
+ "required": [
+ "latitude",
+ "longitude"
+ ],
+ "type": "object"
+ },
+ "locale": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permissions": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "origin": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permission": {
+ "const": "geolocation",
+ "type": "string"
+ }
+ },
+ "required": [
+ "permission",
+ "origin"
+ ],
+ "type": "object"
+ },
+ "maxItems": 100,
+ "type": "array"
+ },
+ "reducedMotion": {
+ "enum": [
+ "reduce",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "timezoneId": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "userAgent": {
+ "maxLength": 512,
+ "minLength": 1,
+ "type": "string"
+ },
+ "viewport": {
+ "additionalProperties": false,
+ "properties": {
+ "height": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "width": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "width",
+ "height"
+ ],
+ "type": "object"
+ }
+ },
+ "type": "object"
+ },
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "lastActivityAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "metadata": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "name": {
+ "type": "string"
+ },
+ "restoredFromStateId": {
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "status": {
+ "enum": [
+ "creating",
+ "ready",
+ "closing",
+ "closed",
+ "failed"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionId",
+ "status",
+ "createdAt",
+ "lastActivityAt",
+ "metadata",
+ "contextSettings"
+ ],
+ "type": "object"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "session"
+ ],
+ "type": "object"
+}browser_session_list1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessions": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "contextSettings": {
+ "additionalProperties": false,
+ "properties": {
+ "colorScheme": {
+ "enum": [
+ "light",
+ "dark",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "deviceScaleFactor": {
+ "maximum": 10,
+ "minimum": 0.1,
+ "type": "number"
+ },
+ "geolocation": {
+ "additionalProperties": false,
+ "properties": {
+ "accuracy": {
+ "maximum": 100000,
+ "minimum": 0,
+ "type": "number"
+ },
+ "latitude": {
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "longitude": {
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ }
+ },
+ "required": [
+ "latitude",
+ "longitude"
+ ],
+ "type": "object"
+ },
+ "locale": {
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permissions": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "origin": {
+ "maxLength": 2000,
+ "minLength": 1,
+ "type": "string"
+ },
+ "permission": {
+ "const": "geolocation",
+ "type": "string"
+ }
+ },
+ "required": [
+ "permission",
+ "origin"
+ ],
+ "type": "object"
+ },
+ "maxItems": 100,
+ "type": "array"
+ },
+ "reducedMotion": {
+ "enum": [
+ "reduce",
+ "no-preference"
+ ],
+ "type": "string"
+ },
+ "timezoneId": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "userAgent": {
+ "maxLength": 512,
+ "minLength": 1,
+ "type": "string"
+ },
+ "viewport": {
+ "additionalProperties": false,
+ "properties": {
+ "height": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "width": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "width",
+ "height"
+ ],
+ "type": "object"
+ }
+ },
+ "type": "object"
+ },
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "lastActivityAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "metadata": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "name": {
+ "type": "string"
+ },
+ "restoredFromStateId": {
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "status": {
+ "enum": [
+ "creating",
+ "ready",
+ "closing",
+ "closed",
+ "failed"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionId",
+ "status",
+ "createdAt",
+ "lastActivityAt",
+ "metadata",
+ "contextSettings"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessions"
+ ],
+ "type": "object"
+}browser_snapshot11 fields changedInput schema / properties / cursorAdded value: +{
+ "maxLength": 160,
+ "minLength": 1,
+ "type": "string"
+}Input schema / properties / includeBoundingBoxesAdded value: +{
+ "default": false,
+ "type": "boolean"
+}Input schema / properties / includeRefsAdded value: +{
+ "default": false,
+ "type": "boolean"
+}Input schema / properties / interactiveOnlyAdded value: +{
+ "default": false,
+ "type": "boolean"
+}Input schema / properties / maxBytesAdded value: +{
+ "exclusiveMinimum": 0,
+ "maximum": 131072,
+ "type": "integer"
+}Input schema / properties / maxCharsAdded value: +{
+ "exclusiveMinimum": 0,
+ "maximum": 100000,
+ "type": "integer"
+}Input schema / properties / maxChildrenAdded value: +{
+ "exclusiveMinimum": 0,
+ "maximum": 1000,
+ "type": "integer"
+}Input schema / properties / maxDepthAdded value: +{
+ "maximum": 100,
+ "minimum": 0,
+ "type": "integer"
+}Input schema / properties / maxRefsAdded value: +{
+ "exclusiveMinimum": 0,
+ "maximum": 100,
+ "type": "integer"
+}Input schema / properties / scopeAdded value: +{
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+}Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "appliedBounds": {
+ "additionalProperties": false,
+ "properties": {
+ "includeBoundingBoxes": {
+ "type": "boolean"
+ },
+ "includeRefs": {
+ "type": "boolean"
+ },
+ "interactiveOnly": {
+ "type": "boolean"
+ },
+ "maxBytes": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "maxChars": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "maxChildren": {
+ "anyOf": [
+ {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "maxDepth": {
+ "anyOf": [
+ {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "maxRefs": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "scope": {
+ "anyOf": [
+ {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "exact": {
+ "type": "boolean"
+ },
+ "frame": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "exact": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "frame": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "exact": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [
+ "scope",
+ "maxDepth",
+ "includeBoundingBoxes",
+ "maxChars",
+ "maxBytes",
+ "includeRefs",
+ "maxRefs",
+ "interactiveOnly",
+ "maxChildren"
+ ],
+ "type": "object"
+ },
+ "contentFormat": {
+ "enum": [
+ "aria-yaml",
+ "aria-yaml-fragment"
+ ],
+ "type": "string"
+ },
+ "omissions": {
+ "additionalProperties": false,
+ "properties": {
+ "maxChildrenNodes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "nonInteractiveNodes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "sourceLimitReached": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "nonInteractiveNodes",
+ "maxChildrenNodes",
+ "sourceLimitReached"
+ ],
+ "type": "object"
+ },
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pagination": {
+ "additionalProperties": false,
+ "properties": {
+ "expiresAt": {
+ "anyOf": [
+ {
+ "format": "date-time",
+ "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "nextCursor": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "offsetChars": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "snapshotId": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "required": [
+ "snapshotId",
+ "nextCursor",
+ "offsetChars",
+ "expiresAt"
+ ],
+ "type": "object"
+ },
+ "partial": {
+ "type": "boolean"
+ },
+ "refs": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "name": {
+ "maxLength": 120,
+ "type": "string"
+ },
+ "ref": {
+ "pattern": "^@e[a-f0-9]{32}$",
+ "type": "string"
+ },
+ "role": {
+ "maxLength": 64,
+ "type": "string"
+ },
+ "tag": {
+ "maxLength": 32,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "ref",
+ "tag"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "snapshot": {
+ "type": "string"
+ },
+ "truncation": {
+ "additionalProperties": false,
+ "properties": {
+ "byMaxBytes": {
+ "type": "boolean"
+ },
+ "byMaxChars": {
+ "type": "boolean"
+ },
+ "originalBytes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "originalChars": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "returnedBytes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "returnedChars": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "truncated",
+ "byMaxChars",
+ "byMaxBytes",
+ "originalChars",
+ "originalBytes",
+ "returnedChars",
+ "returnedBytes"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "snapshot",
+ "contentFormat",
+ "partial",
+ "refs",
+ "appliedBounds",
+ "omissions",
+ "pagination",
+ "truncation"
+ ],
+ "type": "object"
+}browser_state_list1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "states": {
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "stateId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "stateId",
+ "createdAt"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "operationId",
+ "states"
+ ],
+ "type": "object"
+}browser_state_remove1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "removed": {
+ "const": true,
+ "type": "boolean"
+ },
+ "stateId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "operationId",
+ "stateId",
+ "removed"
+ ],
+ "type": "object"
+}browser_state_save1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "state": {
+ "additionalProperties": false,
+ "properties": {
+ "createdAt": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "stateId": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "stateId",
+ "createdAt"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "state"
+ ],
+ "type": "object"
+}browser_uncheckbrowser_visible_text2 fields changedInput schema / properties / locator / oneOfPrevious value: -[
- {
- "properties": {
- "exact": {
- "default": true,
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "strategy": {
- "const": "role",
- "type": "string"
- },
- "value": {
- "enum": [
- "button",
- "link",
- "textbox",
- "checkbox",
- "radio",
- "combobox",
- "heading",
- "listitem",
- "option",
- "tab"
- ],
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- },
- {
- "properties": {
- "strategy": {
- "enum": [
- "text",
- "label",
- "placeholder",
- "testId",
- "css"
- ],
- "type": "string"
- },
- "value": {
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "strategy",
- "value"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "frame": {
+ "description": "Top document or a bounded outer-to-inner chain of semantic iframe element selectors",
+ "oneOf": [
+ {
+ "properties": {
+ "kind": {
+ "const": "main",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "chain": {
+ "items": {
+ "oneOf": [
+ {
+ "properties": {
+ "exact": {
+ "default": true,
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "strategy": {
+ "const": "role",
+ "type": "string"
+ },
+ "value": {
+ "enum": [
+ "button",
+ "link",
+ "textbox",
+ "checkbox",
+ "radio",
+ "combobox",
+ "heading",
+ "listitem",
+ "option",
+ "tab"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ },
+ {
+ "properties": {
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "maxItems": 5,
+ "minItems": 1,
+ "type": "array"
+ },
+ "kind": {
+ "const": "iframe",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "chain"
+ ],
+ "type": "object"
+ }
+ ]
+ },
+ "strategy": {
+ "enum": [
+ "text",
+ "label",
+ "placeholder",
+ "testId",
+ "css"
+ ],
+ "type": "string"
+ },
+ "value": {
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "strategy",
+ "value"
+ ],
+ "type": "object"
+ }
+]Output schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": false,
+ "properties": {
+ "operationId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "pageId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "sessionId": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "truncation": {
+ "additionalProperties": false,
+ "properties": {
+ "maxBytes": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "maxChars": {
+ "exclusiveMinimum": 0,
+ "maximum": 9007199254740991,
+ "type": "integer"
+ },
+ "originalBytes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "originalChars": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "returnedBytes": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "returnedChars": {
+ "maximum": 9007199254740991,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "truncated",
+ "originalChars",
+ "originalBytes",
+ "returnedChars",
+ "returnedBytes",
+ "maxChars",
+ "maxBytes"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "operationId",
+ "sessionId",
+ "pageId",
+ "text",
+ "truncation"
+ ],
+ "type": "object"
+}browser_waitv0.1.2browser_backbrowser_clickbrowser_fillbrowser_forwardbrowser_get_titlebrowser_get_urlbrowser_navigatebrowser_page_closebrowser_page_createbrowser_page_listbrowser_pressbrowser_reloadbrowser_screenshotbrowser_select_optionbrowser_session_closebrowser_session_createbrowser_session_getbrowser_session_listbrowser_snapshotbrowser_state_listbrowser_state_removebrowser_state_savebrowser_visible_textEvery tool is scoped to a distinct resource-action pair: sessions, pages, navigation, state, observation, and individual input actions are clearly separated. The repeated reminders about explicit sessionId/pageId and no global context eliminate most cross-tool selection risk.
Names consistently share the browser_ prefix and mostly follow a predictable resource+action pattern like session_create, page_list, and state_save. Minor deviations such as browser_runtime_info, browser_snapshot, and browser_visible_text add a slightly noun-oriented style, but the naming remains highly readable.
At 35 tools, this is a heavy tool surface for even a full browser-automation server. The tools are individually useful and non-overlapping, but the count pushes past the reasonable threshold and puts a significant selection burden on agents.
The toolkit covers the main browser lifecycle thoroughly: session and page management, navigation, state save/restore, element interaction, waiting, screenshots, and event observation. It lacks low-level escapes like arbitrary JavaScript execution, direct cookie/storage inspection, or file uploads, but those appear intentionally excluded and core workflows remain unblocked.
A paid remote MCP for AI agent browser MCP session, built to return verdicts, receipts, usage logs,
MCP server for building and testing AI agents with multi-model experimentation and insights.
Live browser debugging for AI assistants — DOM, console, network via MCP.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/scrollDynasty/BrowserMesh'
If you have feedback or need assistance with the MCP directory API, please join our Discord server