Banquish MCP

Create a Workspace, named plainly after the task. By default use one per answer. The prompt is the user's request, in their words (at most 1,000 characters). Banquish shows it only on a Share of this Workspace.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "prompt": {
      "type": "string"
    }
  }
}

{
  "title": "Create a Workspace",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}

List the user's Workspaces, most recently viewed first: id, name, Panel count, when the user last viewed it, whether it is archived, and its link. With a query, only Workspaces whose name contains every word.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "query": {
      "type": "string"
    }
  }
}

{
  "title": "List Workspaces",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Rename a Workspace, plainly. The user can undo it with the rest of your Working stretch.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "name"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "minLength": 1
    }
  }
}

{
  "title": "Rename a Workspace",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}

Open a URL as a hidden Staging page with the user's profile: a page you may take Panels from, or one your own tools can't read properly. Find which pages to open with your own search; Banquish has no search. It waits for the page to load and settle, and you get the outline of its Candidate tree: the meaningful parts of the page, largest sections opened first, in at most 40 lines. The result holds the page id and the lines, each one string per candidate: `[id] ^parent kinds tag#htmlId.classes[role=…][aria="label"] @x,y wxh | counts | h:"heading" | "text" | +k`. ^parent is the candidate it sits in (^- for none); kinds are list:N (N items), item, ctl (a control), scrolls:H, fixed, or range a-b of n (a slice of a long level); @x,y wxh is its box on the page in CSS px; counts are the images, media, buttons, inputs and links inside it, left out when none; h: is its heading, left out when the text starts with it, and "text" the start of its text; +k counts candidates inside it not shown. The result says if the page still shows a loading screen, and names the HTTP status when the page answered with an error (400 or above). It answers within about 45 s: a page still loading then gives its page id and "still loading; expand and find wait for it". Use expand and find to see more, as the page is then; ids stay valid while their candidates are on the page. Only your few most recently used pages keep running: one you leave behind (or unused for a few minutes) is unloaded to save memory and opened again when you next use it, keeping the ids of what's still in the same place. Pages on the user's Private sites are refused.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "format": "uri"
    }
  }
}

{
  "title": "Open a page",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

Show a candidate's children on an open page as it is now, in at most 40 lines like open_page's, opening the largest first. A candidate with more than 40 children is paged: pass pageNo for the next pages. Says how many candidates the page gained since you last looked (+N new), with new ids. If the page can't be read again, it is closed: open it again with open_page. After about 45 s it answers "still opening; call expand again" while its page is still opening, or "still working; call expand again" while its work goes on.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "page",
    "candidate"
  ],
  "properties": {
    "page": {
      "type": "string"
    },
    "pageNo": {
      "type": "integer",
      "default": 1,
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "candidate": {
      "type": "string"
    }
  }
}

{
  "title": "Expand a part",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

Find the smallest candidates on an open page, as it is now, whose text, heading, label, id or classes contain every word, in at most 40 lines like open_page's. Says how many candidates the page gained since you last looked (+N new). If the page can't be read again, it is closed: open it again with open_page. After about 45 s it answers "still opening; call find again" while its page is still opening, or "still working; call find again" while its work goes on.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "page",
    "words"
  ],
  "properties": {
    "page": {
      "type": "string"
    },
    "words": {
      "type": "string",
      "minLength": 1
    }
  }
}

{
  "title": "Find on a page",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

Reveal content hidden behind a control on an open page (a tab, an expand toggle, a disclosure, a "more" button): Banquish clicks the candidate for you (or the one button or link inside it, when it holds just one), stopping any request that could write, any navigation and any new window meanwhile, and checks that new content appeared. Returns the updated tree in lines like open_page's: the new candidates, then the outline. Ids you had stay valid; new content gets new ids. A Panel made from the page afterwards comes back in the revealed view after a reload. If the click tries to navigate or open a window, moves the page to another path, or shows nothing new, the reveal is refused with the reason: use content reachable by URL instead. Never on the user's Private sites. Reveals on different pages may run in parallel. After about 45 s it answers "still opening; call reveal again" while its page is still opening, or "still working; call reveal again" while its work goes on.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "page",
    "candidate"
  ],
  "properties": {
    "page": {
      "type": "string"
    },
    "candidate": {
      "type": "string"
    }
  }
}

{
  "title": "Reveal hidden content",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}

Propose a Panel from candidate ids of an open page. Banquish confirms it on the page, which the first Panel from it takes over as its own. The page stays open to you for more Panels: its ids stay valid for expand, find, add_panel and update_panel, and each further Panel gets a fresh copy of the page, where Banquish replays your reveals and finds the parts again, which takes a few seconds (refused if they aren't found). It answers within about 45 s: a Panel whose page is still loading then gives its id with "loading"; a later Fit report or read_workspace shows it settled. reveal and screenshot need the page opened again once a Panel has taken it. Each id is one part: take the smallest part that answers. Several ids make one Composite Panel, for parts of the page that act on each other (a player and its transcript, a chart and its time picker): they show together in one tile and stay live together. exclude takes ids of candidates inside the chosen parts that the Panel leaves out (the site's buttons and menus, an ad, a reply box, the rest of a container whose text you want); any other id is refused with the reason. Mode is "item" (follow this specific thing, the default) or "spot" (whatever occupies this place). Placement is where its Tile goes on the Workspace's grid, as in arrange; without one it goes full width below the last Tile. A width below a Panel's minimum width is taken, and its Panel shows scaled down to as little as 85% of that minimum on the user's screen; below 85% of it, the whole Workspace shows as one column. With h, a Panel's Tile is that tall: a taller Panel scrolls inside it, and a shorter one shows centred in it, which the Fit report mentions. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "workspace",
    "page",
    "candidates"
  ],
  "properties": {
    "mode": {
      "enum": [
        "item",
        "spot"
      ],
      "type": "string",
      "default": "item"
    },
    "page": {
      "type": "string"
    },
    "exclude": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "placement": {
      "type": "object",
      "required": [
        "x",
        "w",
        "y"
      ],
      "properties": {
        "h": {
          "type": "number"
        },
        "w": {
          "type": "number"
        },
        "x": {
          "type": "number"
        },
        "y": {
          "type": "number"
        }
      }
    },
    "workspace": {
      "type": "string"
    },
    "candidates": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "minItems": 1
    }
  },
  "additionalProperties": false
}

{
  "title": "Add a Panel",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}

Read a Workspace: every Tile in one list, in reading order (top to bottom, then left to right), and the user's current window size. Each Tile has its kind and placement on the grid: x and w in 12 columns, y and h in rows of 8 px at the user's laptop window (1512 px wide; gaps 16 px, margins 24 px), each y being where the Tile floats up to. No h means the Tile is as tall as its Panel or Note, at most about two-thirds of the user's window height (a taller Panel scrolls inside it). With h, a Panel's Tile is that tall: a taller Panel scrolls inside it, and a shorter one shows centred in it, which the Fit report mentions. With h, a Note's Tile is that tall, even taller than its text. A Panel has its id, Source page, mode, state (live while it shows its content; restoring, unloaded, broken, ambiguous, needs-peek or not-responding otherwise) and Fit status at the user's window, as the Fit report gives it. tier says how its content was last found: exact, healed (found by similarity after a reload), ambiguous (with the candidate ids on its running page that might be it) or not-found; moved means an item-mode Panel found its content somewhere else on the page; foundByPlace means it found its content by its place and size, as what it is no longer clearly matched. A Note has its id, text and when it was last written. A hidden Tile is a Panel from one of the user's Private sites: only its placement, which you can't move or remove. On a Panel or Note, userChanged means the user moved or resized it since you last placed Tiles on this Workspace (with arrange, or add_panel or add_note with a placement). A broken or ambiguous Panel you meet on a Workspace you're working on is yours to resolve with update_panel as part of your task.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string"
    }
  }
}

{
  "title": "Read a Workspace",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Place any number of Tiles (Panels and Notes, by id) on a Workspace's grid in one call: x and w in 12 columns, y and h in rows of 8 px at the user's laptop window (1512 px wide; gaps 16 px, margins 24 px). No h means the Tile is as tall as its Panel or Note, at most about two-thirds of the user's window height (a taller Panel scrolls inside it). With h, a Panel's Tile is that tall: a taller Panel scrolls inside it, and a shorter one shows centred in it, which the Fit report mentions. With h, a Note's Tile is that tall, even taller than its text. To give a row one height, give its Tiles one h. Only the listed Tiles move. Tiles float up: y orders them, and each sits right under whatever is above it in its columns; a Tile placed on others pushes them, and those under them, down, hidden Tiles too. y is a row in the placements as the last call returned them (this one or read_workspace), so reuse those values, not ones you sent earlier: a Tile given the y of another lands on it. add_panel and add_note return only their own Tile's placement, and one placed on others pushes them down, so call read_workspace before reusing the other Tiles' y. Tiles given the same y in the same columns stack in the order you list them, the first on top. x + w over 12, or a negative or zero value, is refused with the reason, and then nothing moves; so is a Tile you can't see. A width below a Panel's minimum width is taken, and its Panel shows scaled down to as little as 85% of that minimum on the user's screen; below 85% of it, the whole Workspace shows as one column. Returns every Tile's placement. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "workspace",
    "tiles"
  ],
  "properties": {
    "tiles": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "x",
          "w",
          "y",
          "tile"
        ],
        "properties": {
          "h": {
            "type": "number"
          },
          "w": {
            "type": "number"
          },
          "x": {
            "type": "number"
          },
          "y": {
            "type": "number"
          },
          "tile": {
            "type": "string"
          }
        }
      },
      "minItems": 1
    },
    "workspace": {
      "type": "string"
    }
  }
}

{
  "title": "Arrange Tiles",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Add a Note to a Workspace: a few words of your own beside its Panels. Formatted text only, shown in Banquish's own style: "# Heading" (or "## Smaller heading"), paragraphs, "- " or "1. " list items, and [links](https://…); anything else, HTML included, shows as the text it is. No bold or italic: write plain words (** is dropped). At most 2000 characters. Placement is where its Tile goes on the grid, as in arrange; without one it goes full width below the last Tile. With h, a Note's Tile is that tall, even taller than its text. The user can undo it with the rest of your Working stretch. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "workspace",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "placement": {
      "type": "object",
      "required": [
        "x",
        "w",
        "y"
      ],
      "properties": {
        "h": {
          "type": "number"
        },
        "w": {
          "type": "number"
        },
        "x": {
          "type": "number"
        },
        "y": {
          "type": "number"
        }
      }
    },
    "workspace": {
      "type": "string"
    }
  }
}

{
  "title": "Add a Note",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}

Rewrite a Note's text, in the same formatted text as add_note. It keeps its id and placement; place it with arrange. The user can undo it with the rest of your Working stretch. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "note",
    "text"
  ],
  "properties": {
    "note": {
      "type": "string"
    },
    "text": {
      "type": "string"
    }
  }
}

{
  "title": "Update a Note",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}

Remove a Note from its Workspace. The user can undo it with the rest of your Working stretch. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "note"
  ],
  "properties": {
    "note": {
      "type": "string"
    }
  }
}

{
  "title": "Remove a Note",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}

Change a Panel: re-propose its content, change what it leaves out, or switch it between Item and Spot mode, in any combination. Re-proposing is how you resolve an ambiguous or broken Panel: resolve those you meet on a Workspace you're working on as part of your task, and any the user points you at. For an ambiguous Panel, give candidates from the ids read_workspace offers for it. Otherwise open its Source page (or another) with open_page and give that page with candidate ids from it. The page is used as add_panel uses it: the first Panel from it takes it over as its own, and it stays open to you for more Panels; from a page a Panel has taken, the Panel gets a fresh copy where Banquish replays your reveals and finds the parts again (refused if they aren't found, and the Panel gets its old content back). Several ids make a Composite Panel. exclude takes ids of candidates inside the chosen parts that the Panel leaves out. Given without candidates, exclude changes what the Panel leaves out of its parts, with ids from the page you made it from while that page is still open to you; [] brings everything back. mode is "item" (follow this specific thing) or "spot" (whatever occupies this place): from then on the Panel finds its content that way: at once, and again whenever its page loads. It answers within about 45 s: a change whose page is still loading then gives the Panel with "loading"; a later Fit report or read_workspace shows it settled. The Panel keeps its id and placement; place it with arrange.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "panel"
  ],
  "properties": {
    "mode": {
      "enum": [
        "item",
        "spot"
      ],
      "type": "string"
    },
    "page": {
      "type": "string"
    },
    "panel": {
      "type": "string"
    },
    "exclude": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "candidates": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "minItems": 1
    }
  },
  "additionalProperties": false
}

{
  "title": "Update a Panel",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}

Remove a Panel from its Workspace (a hidden Tile can't be removed). The user can undo it with the rest of your Working stretch. Returns the Fit report: at the user's window, which Tiles are scaled below their Panel's minimum width, scroll inside, fell back to crop, are broken or ambiguous, or leave their Tile's width unused, and any gaps between Tiles; and, not as an issue, which Panels are shorter than the h of their Tile, so show centred in it. A Tile whose page hasn't laid it out at its width yet (one not on screen, say) is settling: a later report says how it fits. While a settling Tile's minimum width isn't known, whether the Workspace shows as one column isn't either: oneColumn is left out, and the summary says so.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "panel"
  ],
  "properties": {
    "panel": {
      "type": "string"
    }
  }
}

{
  "title": "Remove a Panel",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}

Read a Panel's current identity and values, kept apart (identity: what it is, e.g. heading, label, link; values: prices, counts, times), with its state and how fresh the read is. Banquish reloads an unloaded page if needed. To protect sites, values read under a minute ago are served as they are, and an unloaded page is reloaded at most every 5 minutes: reads in between get the last values, stale since they were read. A not-responding Panel's page isn't reloaded for a read: it waits for the user to reload it. A read still going after about 45 s gives the last values, stale, and "still reading; call again".

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "panel"
  ],
  "properties": {
    "panel": {
      "type": "string"
    }
  }
}

{
  "title": "Read a Panel",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

An image of one candidate of an open page, and nothing else, for content text can't describe (a canvas chart, an image). Use it sparingly: the Candidate tree usually says enough. After about 45 s it answers "still opening; call screenshot again" while its page is still opening, or "still working; call screenshot again" while its work goes on.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "page",
    "candidate"
  ],
  "properties": {
    "page": {
      "type": "string"
    },
    "candidate": {
      "type": "string"
    }
  }
}

{
  "title": "Screenshot a part",
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

A JPEG of a Workspace as the user's window shows it now (the part in view). With width (CSS pixels), a preview of the whole Workspace at that window width instead: the placement adapted to that width, each Tile's last frame rescaled, so it's approximate. A Workspace not on the user's screen is previewed at the user's window width. Tiles you can't see (Private sites') are plain boxes labelled "Private site".

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "workspace"
  ],
  "properties": {
    "width": {
      "type": "integer",
      "maximum": 3840,
      "minimum": 320
    },
    "workspace": {
      "type": "string"
    }
  }
}

{
  "title": "Picture a Workspace",
  "readOnlyHint": true,
  "openWorldHint": false,
  "destructiveHint": false
}

Signal that you've finished working: the working mark clears, Staging pages no Panel came from are discarded, your changes become one step the user can undo, and the user is told your answer is ready on the Workspaces you changed. No Fit report is sent after it. It returns each Workspace you changed: its name, its link, and what it holds (each Panel's parts and site, each Note's first line). Tell the user what you built from this, with its link. Never quote values.

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}

{
  "title": "Finish work",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}