Lists every open tab with a stable tabId usable by every other tool in this server.

This complements the read-only list-tabs from the base OperaGX connector: that one is for reading; this one hands you the id format the interaction tools (operagx_click, operagx_type_text, operagx_map_elements, ...) expect in their tabId parameter.

Args: none.

Returns: { "tabs": [ { "tabId": string, "url": string, "title": string, "index": number } ] }

Examples:

• Use when: you need to address a specific tab by id instead of relying on the default (first open tab).

• Don't use when: you already have a tabId from a previous call in this session — ids are stable for the lifetime of the browser connection, no need to re-list before every action.

Scans the page for clickable/fillable elements (links, buttons, inputs, selects, ARIA widgets) and returns each with a small integer id, role, text, CSS selector, and viewport coordinates.

By default it also draws numbered badges on the live page — call the base connector's screenshot tool right after this to visually ground the ids, then reference them as elementId in operagx_click / operagx_type_text / etc. Call operagx_clear_annotations when done looking, so the badges don't linger in future screenshots.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to scan. Defaults to the first open tab.

• annotate (boolean, default true): draw numbered overlay badges.

• visibleOnly (boolean, default true): skip elements outside the viewport or CSS-hidden.

• limit (number, default 100, max 500): cap on elements returned, to avoid overwhelming context on dense pages.

Returns: { "count": number, // elements actually returned (<= limit) "totalFound": number, // elements matched before truncation "truncated": boolean, // true if totalFound > count "elements": [ { "id": number, // pass this as elementId to other tools "tag": string, // e.g. "input", "button", "a" "role": string | null, // ARIA role, if set "text": string, // visible text / placeholder / aria-label, truncated to 120 chars "selector": string, // CSS selector (fallback addressing) "rect": { "x": number, "y": number, "width": number, "height": number }, "center": { "x": number, "y": number }, "attributes": { [name: string]: string } // id/class/name/type/role/placeholder/aria-label/value/href } ] }

Examples:

• Use when: "click the login button" -> map_elements first to find its id, then operagx_click with that elementId.

• Use when: a page has more interactive elements than the default limit -> re-call with a higher limit, or narrow with visibleOnly=true (default) to only what's on-screen.

• Don't use when: you already have a fresh element map from a moment ago and the page hasn't changed — re-resolve selectors instead of re-scanning.

Error Handling:

• Returns "No open tabs found..." if the browser has no open tabs — open one first.

Removes the numbered overlay badges left behind by operagx_map_elements.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to clear. Defaults to the first open tab.

Returns: { "ok": true }

Examples:

• Use when: you're done visually grounding element ids and want a clean screenshot again.

Clicks a real point in the browser via CDP mouse input (Input.dispatchMouseEvent), not a JS-level element.click(), so native behaviors (custom canvas controls, drag handles, popups, focus/blur listeners) fire exactly as they would for a human click.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to click in.

• elementId (number, optional): id from the last operagx_map_elements call. Preferred.

• selector (string, optional): CSS selector, if not using elementId.

• x / y (number, optional): absolute viewport coordinates, if not using elementId/selector.

• button ('left' | 'right' | 'middle', default 'left').

• clickCount (number, default 1): 2 for double-click, 3 for triple-click.

Exactly one of elementId, selector, or x+y must be given.

Returns: { "ok": true, "clickedAt": { "x": number, "y": number, "selector"?: string } }

Examples:

• Use when: "click the Submit button" -> map_elements first for its elementId, then click it.

• Use when: a canvas-drawn control has no DOM selector -> click with explicit x/y from a screenshot's pixel coordinates.

• Don't use when: you need to type into a field afterward and haven't focused it yet — use operagx_type_text instead, which clicks and types in one call.

Error Handling:

• Returns "elementId N is not in the current map..." if the id is stale — call operagx_map_elements again.

• Returns "Provide one of: elementId, selector, or x/y." if no target was given.

Moves the mouse over an element or point without clicking, e.g. to reveal a hover-triggered menu or tooltip before interacting with it.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to hover in.

• elementId / selector / x+y: exactly one, same as operagx_click.

Returns: { "ok": true, "hoveredAt": { "x": number, "y": number, "selector"?: string } }

Examples:

• Use when: "open the dropdown that only appears on hover" -> hover over its trigger element first, then operagx_map_elements to find the newly-visible items.

Focuses an element (by clicking it) and types text using real per-character key events (CDP Input.dispatchKeyEvent), so JS keydown/input listeners, IME composition, and masked inputs behave like real typing rather than a value assignment.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to type into.

• elementId / selector / x+y: exactly one, same as operagx_click — identifies the field.

• text (string): the text to type.

• clearFirst (boolean, default true): select-all + Backspace before typing, to replace any existing value instead of appending.

• delayMs (number, default 20): delay between keystrokes; raise it for sites that debounce input handling.

Returns: { "ok": true, "typedInto": { "x": number, "y": number, "selector"?: string } }

Examples:

• Use when: "enter 'tomsmith' in the username field" -> map_elements for its elementId, then type_text with text="tomsmith".

• Don't use when: filling several fields at once — use operagx_fill_form instead, it's one tool call for the whole form and can submit at the end.

Sends a key or chord to the focused element or page, e.g. "Enter", "Escape", "Tab", "Control+A", "Control+Shift+ArrowLeft". If a target is given, it is clicked/focused first.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to send the key to.

• elementId / selector / x+y (all optional): if given, focus this element first; otherwise the key goes to whatever currently has focus.

• key (string): Playwright key syntax, e.g. "Enter" or "Control+A".

Returns: { "ok": true }

Examples:

• Use when: "press Enter to submit the search" -> press_key with key="Enter" (target optional if the search field is already focused from a previous type_text call).

• Use when: "select all text in this field" -> press_key with the field's elementId and key="Control+A".

Fills multiple fields in one call and optionally submits at the end. Each field targets an element the same way as operagx_click (elementId/selector/x+y).

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab to fill.

• fields (array, min length 1): each item is { elementId? | selector? | x?+y?, value: string }.

• submitKey (string, optional): e.g. "Enter" to press after the last field. Omit to skip.

Returns: { "ok": true, "fields": [ { "filledAt": { "x": number, "y": number, "selector"?: string }, "value": string } ] }

Examples:

• Use when: "log in with username tomsmith and password foo" -> map_elements for both field ids, then fill_form with both, submitKey="Enter".

• Don't use when: only one field needs filling — operagx_type_text is simpler for that case.

Chooses an option in a native dropdown by value, label, or index.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab.

• selector (string): CSS selector for the element.

• value / label / index: exactly one, identifying which option to choose.

Returns: { "ok": true, "selected": string[] } // the value(s) selected, per the DOM API

Examples:

• Use when: "choose 'Option 2' from the dropdown" -> select_option with the select's selector and label="Option 2".

Error Handling:

• Playwright throws if the selector doesn't resolve to a , or the option doesn't exist — the error message names the selector and requested value.

Performs a real mouse-down / move / mouse-up drag between two points or elements, so drag handlers relying on genuine mousemove events (sortable lists, sliders, canvas handles) receive the motion they expect.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab.

• from / to: each { elementId? | selector? | x?+y? }, identifying the start and end points.

• steps (number, default 10): intermediate mousemove steps between from and to.

Returns: { "ok": true, "from": { "x": number, "y": number, "selector"?: string }, "to": { "x": number, "y": number, "selector"?: string } }

Examples:

• Use when: "drag item A onto the trash icon" -> map_elements for both elementIds, then drag_and_drop from item A's id to the trash icon's id.

Scrolls the page with a real mouse-wheel event, or scrolls a specific element into view.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab.

• elementId / selector (optional): if given, scrolls that element into view instead of wheel-scrolling the page.

• deltaX / deltaY (number, default 0): wheel scroll amount in CSS pixels, used only when no elementId/selector is given.

Returns: Either { "ok": true, "scrolledTo": { "x": number, "y": number, "selector"?: string } } or { "ok": true, "delta": { "x": number, "y": number } }

Examples:

• Use when: "scroll down to load more results" -> scroll with deltaY=800.

• Use when: "scroll the footer link into view" -> scroll with that link's elementId.

Waits until a selector reaches a given state, or times out.

Args:

• tabId / tabIndex / matchUrl / matchTitle (optional): which tab.

• selector (string): CSS selector to wait for.

• state ('attached' | 'visible' | 'hidden' | 'detached', default 'visible').

• timeoutMs (number, default 10000).

Returns: { "ok": true }

Examples:

• Use when: "wait for the spinner to disappear before continuing" -> wait_for with the spinner's selector and state="hidden".

Error Handling:

• Throws a timeout error naming the selector and state if it isn't reached in time.