KitchenSink4Web

Find elements by text, role plus accessible name, natural-language description, CSS, or XPath, and get back refs you can act on plus a note on what was not searched. `role='button'` narrows any query to one element role (field finding: 'Comment' alone matched 12; with the role filter it matches the one button). This is the cheap targeted follow-up that pairs with get_page_view: the page view tells you what string to look for, and this retrieves it for a fraction of a full read. Ambiguous results are listed rather than resolved, and zero results come back with the nearest misses so a miss is a one-turn recovery. The search covers the main document and every open shadow root in it, and the matches it returns from a shadow root are actable like any Same-origin iframes are searched too and the result says which ones it entered. Two things stay out and the result counts both: cross-origin iframes, which no tool here opens, and closed shadow roots, which no tool can reach. XPath is the one kind that does not enter a shadow root. `location={'region': 'r7'}` (or a ref, form, or table from a read) narrows the search to that subtree, components inside it included, and the first result line names the scope that was searched.

Read the action log. Returns one record per call, paginated, carrying the timestamp, lane, page, URL, resolved target with its human label, redacted arguments, outcome, any rebind, any confirmation decision, and the budget counters at that moment. This is an operational record for the user, so you can always know exactly what was done even where a web action cannot be undone. It is not forensic and not evidence.

Read a page as an ORIENTATION, not a transcript, under a token budget it never exceeds whatever the page size. Returns identity, landmark regions each priced with the cost to expand it, the interactive surface with refs you can act on, a digest or app skeleton, form and table inventories, an account of what was NOT read and why, and the next call for anything unexpanded. `location` scopes to one region ref, `budget_tokens=2500` suits a subagent, `mode='links'` includes in-prose links at their real cost. `since=<read_token>` is the cheap repeat read: only what changed, refs kept, a few hundred tokens instead of a fresh read, and it falls back to a full read when the page navigated in between and nothing survives to diff. Open shadow roots are read and their contents get refs you can act on; closed roots cannot be reached by any tool and are counted at creation, so the completeness block reports both numbers rather than one confident zero. Same-origin iframes are entered and read, and their contents get refs naming the frame they came from; a cross-origin frame is never entered, because its document belongs to an origin the page itself cannot read either, and the completeness block counts every frame it did not open.

Report what this server is and what it is running: the product and PyPI package names, the version a client was handed at initialize, the homepage and repository, the sibling servers in the same suite, the tool surface registered in THIS process (how many tools, how many of them are the lite core, which capability packs are loaded and which exist, and the read-only grade and consent scope in force), the test figures measured for this release, and the host Python and platform. Counts come from the live registry, so they describe the process you are connected to rather than the product in general. Needs no browser, opens no page, and reveals no path or user name, so a bug report can carry the output as it stands.

Extract readable prose from a page or one region of it, paginated by `start_index` so a long article is read in bounded pieces rather than one unbounded dump. Text arrives as labeled data with its origin stated, and hidden regions are stripped and counted rather than silently dropped or silently included. Hidden content IS retrievable, deliberately: include_hidden=true returns it in a separately labeled section with the hiding technique named per block. There is no silent middle tier, because display:none is a real injection channel; the labeled route is the whole design. Prose inside open shadow roots is read, the same as get_page_view reads it; closed roots are counted and stay unreadable. Prose inside same-origin iframes is read after the main document, each frame under a header naming it and its origin, because one page can now deliver text from several documents and a single origin in the label would be a claim about only one of them.

Get recipes for this server: the cheap-read-then-act pattern, the auth workflow (headed handoff plus saved state), reading strategy, budgeting, troubleshooting a page that will not read, the subagent budget setting, lanes, what each capability pack contains with the exact launch flag that loads it, what a site profile is and where it lives, and how to record and replay a multi-step flow. Packs are chosen at launch rather than at runtime, so this is where you learn which flag you need before restarting. Tool availability reflects the packs this server was started with.

One session is one browser. `open` starts one on a chosen lane (the first navigate of a conversation can open one for you, and says so when it does); `close` ends the browser; with auth state saved, the login survives; the session never does. `status` reads liveness first, so a dead browser says so, then lists every session this server holds with its pages, budgets, and what is shared: sessions belong to the server process, not to a conversation. `capabilities`, `budget`, and `reset_budgets` report and manage limits. `handoff` hands the window to the human for a login, an MFA prompt, or a bot wall. `export_handle` and `import_handle` move a live session between conversations on this machine: see `get_workflows(task='session-transfer')`. `lanes` is the local lane database (status, export, import, erase). `profiles` reloads site profiles from disk. On open, `auth_state` loads a saved login, `contexts=2` gives one session two independent cookie jars, and `device`, `viewport`, `locale`, and `timezone` set what pages in this session believe about their environment.

List, open, select, or close tabs, report which is focused, and capture pages a click opened in a popup. Mints and returns the explicit page handles every other tool accepts, which is how browser state survives across calls without relying on protocol sessions. Closing a page invalidates its refs and its delta read tokens, and the result says so rather than leaving a later failure to explain it. On a session with more than one cookie jar, `context` says which jar a new tab opens in and every listed page says which jar it belongs to.

Watches one URL for one deterministic change while this server runs. Four conditions: content_hash, text_appears, text_gone, selector_count; the same page state always answers the same way. Nothing is pushed anywhere: report is how you ask what happened, and check_now forces a check. A monitor that could not check reports stale with the failure, never unchanged. Checks run in a dedicated headless session, never the caller's. There is a floor on the interval and caps on monitors and daily checks; a 429 is honored rather than retried; a monitor that keeps failing pauses itself.

Go to a URL, or go back, forward, reload, or stop, and wait for the load state you name. Can be the FIRST call: with no `page`, navigate opens a browser session itself (bundled Chromium, headless) or uses the one already open, and returns the minted session and page handles. Returns the final identity after redirects, the HTTP status, a robots.txt advisory, and a verdict on whether the destination is a bot wall, a CAPTCHA interstitial, or a login wall, so a blocked request is reported as blocked instead of surfacing as a timeout or an empty page that invites a retry loop.

Scroll by an amount, to a named element, to the end, or inside a specific container, plus a next-chunk mode that remembers position across calls so a long page is walked without re-reading it. Reports how much content is now reachable and how much remains below, and names virtualized containers where the DOM holds far fewer rows than the page claims, rather than presenting a partial list as complete.

Wait for text to appear or disappear, an element to reach a state, a URL to match, or a JS predicate to hold. EVERY condition is checked against the current state first and returns immediately when it already holds, so a wait issued after the thing already happened costs nothing instead of timing out (a URL wait could otherwise expire on a navigation that had already finished). A `url` value without wildcards matches as a substring; use * and ? for globbing. Real timeouts, and a failure that says what was awaited and what was observed instead.