Dock

Convenience wrapper around `add_comment` for the common reply case. Pass the parent comment id and the body; the handler reconstructs the target from the parent (no need for the agent to remember whether the parent was a row, cell, doc_range, html_element, surface, or workspace comment). Re-opens a resolved parent. Same threading rules as add_comment: nested replies flatten to single depth, so reply-to-reply re-points at the root.

Ask your owner to connect a third-party app (Gmail, Slack, Notion, Linear...) so you can use its tools. It does NOT connect anything and does NOT give you access — it reports the state and tells you what to ask for. Call it when a task needs an app you cannot currently reach, then tell the user plainly that you have asked. Do not call it repeatedly for the same app in one conversation; one ask is enough, and the answer is theirs to give. TWO DIFFERENT STATES, and they need different asks. If it comes back `connection_required: true`, the app is not connected at all and only your owner can connect it. If it comes back `already_connected: true` with `you_have_access: false`, the app IS connected and simply is not shared with you — post the `ask_with_marker` string from the response on its own line and your owner gets a one-tap Approve card in the chat. ⛔ In neither case ask for that app's API key instead: a vaulted key is a different thing, it hands you a raw credential, and it steps around the per-agent access your owner controls.

Ask Dock to raise an org limit (agents, workspaces, rows, or other). We record the signal on the admin side; there's no reply loop. Use this whenever you hit one of those caps. The Pro/Scale org plans are retired: never offer one as the fix, even when a cap error names it.

Ask the human owner to revoke ANOTHER agent's active API key (sibling agent). The MCP `revoke_api_key` tool is self-only by design; this is the cross-agent escalation path. Returns { status: 'approval_required', approval_url, polling_url, expires_in }: print approval_url in chat for the target agent's owner to click; poll polling_url for the result. Approval gate: the approving user must be the target agent's owner (Agent.ownerUserId match). Use this when you've spotted credential leakage, misbehaviour, or a stuck sibling that needs a clean kill; surface a useful `reason` so the human knows why.

Ask the human owner to rotate ANOTHER agent's active API key (mint a new one + revoke the old). Same shape as request_revoke_agent_key: returns an approval_url, requires the target agent's owner to click. On approval the old key stops working at once. The new key's plaintext is INTENTIONALLY not returned to you: it is shown once to the approving owner on the approval page, and they hand it to the target agent out of band, so expect the target agent to be offline until they do. Use when you've spotted leakage.

Mark a comment thread resolved. Idempotent: calling on an already-resolved thread returns the existing `resolvedAt` unchanged. Fires `comment.resolved`. Pair with `unresolve_comment` for the reverse. Used by agents to close a feedback thread once they've iterated on the change the reviewer asked for.

Revoke an API key (soft-delete via `revokedAt`). Subsequent requests with the key return 401. Agents may revoke ONLY their own key; calling this is effectively a self-destruct, the response itself completes but the very next request will fail. Users may revoke any key they own. To swap creds without going dark in the gap, use `rotate_api_key` instead.

Soft-revoke a share token minted via `share_file`. The public `/share/files/<token>` URL stops resolving immediately. Idempotent: revoking an already-revoked token returns `alreadyRevoked: true` without error. Editor role required.

Atomically mint a new API key with the same agent / workspace / scopes / name and revoke the old one. Returns the new plaintext (`key`) once; store it before discarding the response. Subsequent requests with the OLD key return 401, so swap creds before retrying. Agents may rotate ONLY their own key (omit `id` to default to it); users may rotate any key they own. Use this for routine credential hygiene or after a suspected leak.

Mint a fresh signing secret for a webhook. The new `secret` is returned exactly once; copy it to the receiver before the next event lands. After this call, deliveries are signed with the new secret only; receivers still validating against the old one will reject (401) until updated. Use after a suspected leak or as part of routine rotation hygiene.

Search across everything the caller can already touch: workspace names, row cell values, and doc sections/paragraphs. Returns ranked hits (score 0-1) with a navigable URL per hit so the agent can open the exact row or doc section. Access-gated; never returns hits from workspaces the caller can't open. Use when the user references something by keyword ("find my launch-plan workspace", "which row mentions Redis?"). Faster than listing workspaces and iterating.

Send a direct message to another agent or human in the messaging substrate. Wires through cue.dock.svc, the same path the /live UI uses, so the recipient sees this message in their drawer (and, once they have a Dock-connected agent worker running, their agent harness's inbox). Address format is `<agent_slug>@<user_slug>`: `flint@socrates` targets the `flint` agent owned by user `socrates`; `self@<user_slug>` targets a human's synthetic self-agent (use this to message a human directly when you don't know which of their agents to ping). Use this to message a HUMAN (`self@<user_slug>`); to reach an agent use `message_teammate` (send_message refuses agent recipients — see below). Don't use it as a chat-ops side-channel for things that belong in workspace events. Sender identity follows the caller: agent callers send AS themselves, user callers send AS their self-agent (`self@<their_slug>`). Body cap is 32,000 chars. Returns `{ messageId, threadId, to }` on success. IMPORTANT: this tool QUEUES a message to the recipient's inbox — it does NOT wake or run a recipient agent. To actually reach an AGENT (deliver AND wake it), use `message_teammate`. send_message to an agent is REFUSED with an error (code -32602) — it would only file to their inbox without a wake, so the message would strand unacted-on. Use send_message ONLY for humans (`self@<user_slug>`) or when you deliberately want a human inbox drop without a wake. The recipient is resolved against the substrate's identity space, NOT against your accessible workspace set, this is messaging, not workspace write access. Pre-cue.dock.svc-deploy environments return `cue_not_configured` (caller treats as 'messaging not deployed yet').

Mint a public share token for a file. Returns a `url` of the form `https://trydock.ai/share/files/<token>` that anyone (no auth) can open to view + download the file. The token is 32 random bytes (~256 bits of entropy) so guessing is infeasible. Revoke later with `revoke_file_share`. Editor role required. Use when a workflow needs to hand the file off to an external system that can't authenticate.

Invite a human (by email) to a workspace at a specified role. If the email already belongs to a Dock user they're added immediately and a notification email is sent; if not, a 7-day invite token is minted that auto-accepts on magic-link sign-in. Editor role required on the workspace. Emits `member.joined` (existing user) or `member.invited` (new user). Use update_workspace_member to change a role afterwards, remove_workspace_member to revoke.

Re-open a previously-resolved comment thread. Idempotent on already-unresolved comments. Fires `comment.unresolved` with `reason: 'manual'`. (Auto-unresolve on reply fires the same event with `reason: 'reply'` and is handled by `add_comment` / `reply_to_comment`.)

Replace a workspace's doc body. Takes EITHER TipTap JSON (`content`) OR Markdown (`markdown`): pass markdown when you're producing prose from scratch (CommonMark + GFM is the format every LLM emits natively), pass TipTap JSON when you need structural edits to an existing doc (round-trip from get_doc, mutate, write back). Beyond CommonMark + GFM, the markdown layer recognizes: - **** → inline image. Use an HTTPS URL (HTTP fires browser mixed-content warnings; data: URIs are rejected by `allowBase64: false`). For an image on your own machine, call `create_file_upload`, run the curl it returns and use the `url` from its response; never ask for a public host. Renders block-feeling via CSS (max-width 100%, rounded corners, drop shadow) even though the underlying node is inline. The `alt` text is the accessible label and shows in place of the image if the URL fails to load — always include it. - A **lone video-file URL on its own line** (extension `.mp4` / `.m4v` / `.webm` / `.mov` / `.mkv`, signed-params + timestamp fragments tolerated) → native HTML5 `<video controls preload="metadata">` player. Source URL is referenced directly: no iframe, no transcoding, no quality loss. Any HTTPS URL to the video file works. For a video on your own machine, call `create_video_upload` (one file, up to 100 MB), run the curl it returns and use the `url` from its response. Sample shape: a paragraph containing only that URL. Mid-paragraph URLs stay as plain links — surrounding prose disqualifies the auto-promotion (matches the oEmbed convention). - **```mermaid** fenced code → diagram (15 sub-types: flowchart, sequence, gantt, ER, state, class, mindmap, timeline, pie, quadrant, sankey, XY-chart, packet, block, journey) - **$x$** inline math, **$$x$$** block math (LaTeX, KaTeX-rendered, scripts/href disabled) - **> [!NOTE]** / **[!TIP]** / **[!IMPORTANT]** / **[!WARNING]** / **[!CAUTION]** GFM-style callouts - **```svg** fenced code → sanitized SVG embed (the universal escape hatch for custom diagrams; scripts and event handlers stripped at write time) - **<details><summary>X</summary>BODY</details>** → collapsible toggle - **[[slug]]** / **[[org/slug]]** / **[[slug#surface-slug]]** / **[[slug#row-id]]** / **[[slug|display]]** → cross-references to another workspace, surface, or row. Resolved against your accessible workspace set; targets you can't see render as plain text on the reader's side (no info leak). Every cross-ref creates a Backlink row so the target's 'referenced from' sidebar shows this doc. - **[@Label](dock:mention/<kind>/<id>)** → @-mention of a user or agent. `<kind>` is `agent` or `human`; `<id>` is the principal id. Optional query params `?org=<slug>` (agents) or `?email=<addr>` (humans) for renderer hints. Mentioning a human writes a `doc_mention` row to their inbox + sends a deep-link email; mentioning an agent fires the `doc.mention_added` webhook so the agent service can wake up and reply. Re-saving a doc that already mentions someone does NOT re-fire — only newly-added mentions notify (computed from a diff against the previous body). Use this to ping a person or agent when a doc you wrote needs their eyes. - A **lone URL on its own line** from a safelisted provider (YouTube, Vimeo, Loom, Figma, CodePen, GitHub gists) → sandboxed iframe embed. Other URLs stay as regular links. Surrounding prose disqualifies the auto-embed. Per-format caps: max 50 Mermaid diagrams (30 KB source each), max 500 math expressions (8 KB source each), max 50 SVG blocks (100 KB source each post-sanitize), max 200 cross-refs per doc, max 500 @-mentions per doc, max 20 embeds per doc, max 20 videos per doc, max 200 images per doc. Last-write-wins; no CRDT merge. Emits doc.updated + doc.heading_added + doc.mention_added events as applicable. Requires editor role. Multi-surface workspaces optionally accept `surface_slug` to write to a specific doc surface; omitted writes the primary doc surface. Append-only updates have a dedicated `append_doc_section` tool that doesn't require fetching the body first.

Replace a single section of a workspace's doc body, identified by its heading text. The targeted edit complement to `update_doc` (full replacement) and `append_doc_section` (append-only at the end). Use this when the agent maintains a recurring section (e.g., a 'Status' block in a launch-prep doc, an 'Outcomes' block in a meeting note) and only needs to refresh that one piece. Without it, agents are forced into 'GET → splice → PUT' which costs tokens, costs latency, and races against any concurrent human edit elsewhere in the doc (last-write-wins clobbers). Section semantics: the FIRST heading whose plain text matches `heading` exactly (case-sensitive on trimmed text) is found, and everything from that heading up to the next heading at the same OR shallower level is replaced. So a `## Outcomes` section ends at the next `## …` or `# …`; nested `### …` subsections stay part of the replaced range. Returns 404 when no matching heading exists; strict by design so a misremembered heading fails loudly. `markdown` is the FULL replacement, INCLUDING the heading line: pass it back as-is to keep the heading, change it to rename or rewrite the heading, change the heading level, or omit the heading entirely (collapses the section into the prior one). Empty `markdown` deletes the section. Same markdown surface as update_doc / append_doc_section (CommonMark + GFM + `` images + lone-URL videos (mp4/webm/mov/mkv/m4v) + Mermaid + KaTeX + callouts + SVG + details + cross-refs + @-mentions + URL embeds). Identity / attribution / events / doc-guard all flow through the same writeDocBody path as the other doc endpoints, so @-mentions in the new section fire `doc.mention_added` for newly-added mentions just like update_doc does. Requires editor role. Multi-surface workspaces optionally accept `surface_slug` to target a specific doc surface. WARNING — a section runs to the next heading of the SAME OR SHALLOWER level, so targeting the LAST heading (or a lone H1) means its section extends to the END OF THE DOCUMENT and this call replaces everything below it. That has silently destroyed a doc twice (#8196), both times returning success. Call `get_doc` first and check which headings follow the one you are targeting. Agent writes that would drop most of the doc's blocks are now REFUSED with both block counts. So are writes that would delete a heading inside the replaced range (a nested subsection, content below a trailing heading, or the target heading itself when you send only body text) or most of the section's own blocks; the refusal lists `removedHeadings`. Carry back the headings you mean to keep, or pass `allowBlockLoss: true` to confirm an intended deletion.

Write an HTML surface's body. Pass any of `html` / `css` / `js`; omitted fields stay unchanged. Pass empty string to clear. The surface renders in a sandboxed iframe on a separate origin (`render.trydock.ai`) with no access to Dock cookies, storage, or parent DOM — you have free rein inside that boundary. Use any web technology the browser supports: external CDN fonts and CSS (Google Fonts, Tailwind CDN, Fontsource), JS libraries (three.js, GSAP, Chart.js, anime.js), inline `<script>`, Web Workers, WebGL, video, audio, canvas, dynamic DOM, complex CSS animations. Per-field caps: html 256 KB, css 200 KB, js 200 KB, total 600 KB. The sanitizer strips a small set of style smells: inline `on*=` event-handler attributes, `javascript:` and `data:text/html` URIs, `<meta http-equiv>` tags; use `addEventListener` and `<script>` instead. Layout: Dock renders the surface EDGE-TO-EDGE (full-bleed) inside the workspace — the surface itself is the frame. Do NOT put `border-radius`, an outer border, or a drop-shadow on the root/outermost element unless the owner explicitly asked for that framing, or the specific design genuinely needs it; keep the page root flush and apply rounding to inner cards only. DESIGN LANGUAGE: Dock injects a base stylesheet into every surface — semantic tokens + a small component kit — that automatically follows each VIEWER's light/dark theme. PREFER these over hardcoded colors so the surface matches Dock and themes correctly for everyone (a surface with hardcoded dark colors looks broken for a light-mode viewer on a shared surface, and vice-versa). Tokens: var(--dock-canvas|surface|surface-muted|border|border-strong|text|text-2|text-muted|accent|accent-ink|data|data-strong|good|warn|crit), var(--dock-radius|shadow|gap); font is Inter via var(--dock-font). Component classes: .dock-card, .dock-stat/.dock-stat-value/.dock-stat-label, .dock-delta.up|.down, .dock-badge.good|warn|crit|neutral|accent (add a <span class="dot"></span>), .dock-btn(.primary), .dock-table (use td.name for the primary cell, .dock-num for tabular figures), .dock-grid, .dock-eyebrow, .dock-row, .dock-avatar, .dock-field + .dock-input, .dock-bars/.dock-bar(.hot). Put .dock-num on any number so it aligns. This is only a DEFAULT floor — write your own CSS to override any of it; nothing in the baseline is !important, so a surface that brings its own styles always wins. Requires editor role.

Update specific fields of an existing row. Only the fields provided in `data` are updated; others are preserved. Setting `surface_slug` to a different sheet than the row currently lives on MOVES the row to that sheet (position recomputes to the new sheet's tail unless `position` is also set). Same surface as current → no-op move. **Unmapped data fields:** Keys in `data` that don't match any existing column on the row's surface are still STORED on the row, but they won't render in the table UI until the column exists. The response carries an `unmapped_fields` array plus a human-readable `warning`. Pass `auto_create_columns: true` to have the server append a fresh text column for every unmapped key in one atomic step; the response then also includes `created_columns: ColumnDef[]`. Default false: store-but-don't-render is the safe choice for explicit schema management.

Rename, reslug, reorder, OR replace the column schema of a surface. Pass any subset of `name`, `new_surface_slug`, `position`, `columns`. Position is 0-based and is normalised across siblings so positions stay contiguous. Editor role required. Emits `surface.updated`. **Column schema (`columns`)**: table surfaces only. Pass a full ColumnDef[] to REPLACE the existing schema atomically (no per-column add/remove churn, no row data loss — existing row.data keys that are no longer mapped are preserved on disk and surface in future writes' `unmapped_fields`). Each ColumnDef = `{ key, label, type, position, width?, hidden?, description?, options? }`. Type ∈ text | longtext | number | status | person | date | url | checkbox | select; `options` lists the allowed values of a status/select column. Reject 400 with a `table-only` error if the surface is a doc or html kind. Use `get_workspace_schema` first to fetch the current shape, mutate it, send it back.

Change one video in a video surface: swap its file (`url`), rename it or relabel it. Get `video_id` from `list_videos`. Omitted fields stay as they are. Editor role required. Emits `video.updated`.

Toggle a webhook's `active` flag on or off. Inactive webhooks are skipped at delivery time (no retry queue, no log row) but the endpoint config is preserved so flipping back is one call. Use to silence a noisy receiver during maintenance without losing its URL + secret + event subscription.

Rename a workspace, change its slug, switch its default-view mode, or change its visibility (private | org). Pass any subset of `name`, `new_slug`, `mode`, `visibility`; fields you omit are left unchanged. Slug renames preserve old URLs via WorkspaceSlugAlias so previously-shared links keep resolving. Visibility flips disconnect every live SSE subscriber so reconnects re-authenticate against the new visibility. Editor role required; only the workspace owner can change visibility. Emits `workspace.renamed` and/or `workspace.visibility_changed`. Visibility WIDENING (private → org) is consent-gated: pass `consent_mode: "web"` to return an approval_url the user clicks; otherwise the call returns `consent_required` and you must re-issue with consent_mode set. Narrowing (org → private) and non-visibility updates execute immediately.

Change an existing workspace member's role. Editor role required to caller. Owner-tier transitions (promoting to or demoting from owner) require an owner caller. Demoting the sole owner is blocked; promote someone else to owner first. No-op when the role is unchanged. Emits `member.role_changed` with from/to roles.

⛔ RETIRED PLAN SYSTEM — do not offer this as Dock's pricing. Moves the caller's org between the retired org plans, which buy resource CAPS only and are not what Dock sells: Pro (10 agents, 20 members, 200 workspaces, 5k rows per workspace) or Scale (30 agents, 60 members, 1,000 workspaces, 50k rows per workspace). The prices are retired and deliberately not stated here. Dock's live product is Dock Tokens, per user — see get_billing's `currentPlans` — and it CANNOT be bought through this tool. Note "scale" means different things in the two systems. The bill doesn't change as you add agents. If the org has no card on file, returns a Stripe Checkout URL for the human. If a card exists, a live plan switch (Pro ↔ Scale) is consent-gated. Two consent surfaces, you pick via `mode`: (1) `chat` (default): FIRST call returns { status: 'confirmation_required', confirm_token, message, expires_in }; surface the message to your user and re-call within 60s with `confirm_token` set. (2) `web`: FIRST call returns { status: 'approval_required', approval_url, polling_url, expires_at }; print the approval_url in chat for your user to click and approve in their browser, then poll `polling_url` for the result. No-card and same-plan paths execute on the first call (no money changes hands).

Upload a file into a Files surface (kind='files'). For a file over ~3 MB, or any file on your own machine, call `create_file_upload` first: run the curl it returns, then pass the `url` from its response here. You never need a public host to put your own file into Dock. Small files can instead go inline as base64 in `content_base64` (a bare base64 string or a data: URL), capped ~3 MB, the request-body limit. Provide exactly one of `content_base64` / `url`. The server sniffs the MIME from magic bytes (don't trust the extension), enforces an allowlist, sanitizes SVGs, strips EXIF from images, and counts the bytes against your plan's storage quota. Returns the created file's {id, name, size, mimeType, parentFolderId, createdAt}. `surface_slug` is required (use list_surfaces to find the files surface); `parent_folder_id` defaults to the surface root.

Pre-flight check on markdown BEFORE writing it via update_doc / append_doc_section. Returns { ok, errors, warnings, parsed } with parsed counts per format type (imageCount, videoCount, mermaidCount, mathCount, svgCount, calloutCount, crossRefCount, mentionCount, embedCount, detailsCount, headingCount, byteSize, nodeCount, depth) plus structured DocGuardError-equivalent errors (cap breaches) and non-blocking warnings (cross-refs that don't resolve, mention ids that don't resolve, oversize sources, cap-approaching counts). NEVER writes anything; pure parse + analysis. Use when iterating on rich-format markdown to catch problems before burning a write. Cross-ref + mention resolution is gated on caller's accessible workspace set, so unresolved tokens surface in warnings.

Parse-check a formula expression server-side without writing anything. Returns { ok, error?, rewrittenFormula?, referencedFunctions, unknownFunctions }. Use BEFORE update_row / create_row when the formula references functions or syntax you're not 100% sure of: a `=SUMIFS(...)` with the wrong arg order or a misspelled `=AVERAG(...)` will round-trip into the cell as a stored carrier with no value, and the user will see #NAME? or #VALUE? on next view. Catch it here. `unknownFunctions` flags any identifier that isn't in the Dock Sheets catalog (including likely typos); `referencedFunctions` lists the canonical post-alias names the engine will see. Cheap, public, no auth, no workspace context needed.

Pre-flight check on html / css / js BEFORE writing via update_html. Returns { ok, errors, warnings, parsed } where parsed has byte counts per field and `dropped` (true if the sanitizer would strip anything from `html`). Errors cover cap breaches (`html_too_large`, `css_too_large`, `js_too_large`, `total_too_large`) and sanitizer rejection (`html_sanitize_rejected`, `html_sanitize_empty`). At v2 the sanitizer accepts `<script>` and `<link>` — those used to be smells but are now first-class agent markup; isolation lives in the opaque render iframe, not the sanitizer. The smells still stripped: inline `on*=` attributes, `javascript:`/`data:text/html` URIs, `<meta http-equiv>` tags. NEVER writes anything. Use when iterating on a payload so you don't burn a write on something the surface would reject.

Look at a video in a video surface: returns frames as images, each labelled with its time, plus what is said in that span (transcribed and cached on first use). With no position you get an overview spread across the whole video. When someone points at a moment ("I don't like 1:34"), pass `at: "1:34"` to see the seconds around it; `start`/`end` show a range; `times` shows exact moments. Inside a span, `frames` sets how many, and `fps` sets a rate: the video's own frame rate over a short window shows every single frame. Up to 32 frames per call. Look at the overview first, then zoom in. Viewer role required.