artifact_patch
ChatGPTPartially edit an artifact's source code by finding and replacing a specific string. Uses 3-way merge to safely combine with concurrent human edits. Call artifact_read first to see the current source. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.
artifact_read
ChatGPTRead the current source code of an artifact via real-time collaboration. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.
artifact_update
ChatGPTReplace the entire source code of an artifact. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this artifact once — you cannot allow it yourself — so treat a rejection as normal; published pages never write. MCP App HTML/static preview is off by default on artifact_read; call preview_resource when an inline preview is useful.
canvas_add_artboard
ChatGPTAdd one Design Component HTML artboard under a new .dc.html filename in a file-based canvas.
canvas_add_text
ChatGPTAdd one plain-text box to a page of an element-based canvas.
canvas_read
ChatGPTRead a native Canvas (infinite board): its pages, one page's elements (bottom first, absolute x/y/w/h), next_free_spot and state_hash for canvas_update. Frame html is excerpted unless include_html. File-native: returns its files.
canvas_replace_artboard
ChatGPTReplace the HTML content of one existing Design Component artboard in a file-based canvas.
canvas_replace_element_text
ChatGPTReplace the text of one text box, sticky note, shape or connector on an element-based canvas.
copy_resource
ChatGPTCopy a resource (document, table, artifact, file or whole folder) into a workspace or folder as an exact, independent copy. Needs export access to the source and write access where it lands; stays within one organization.
create_artifact
ChatGPTCreate an Artifact, Diagram, Design, Slide, Component, or Screen. Generic Artifacts require exactly one of source or template_id; Artifact variants may omit both to use their maintained starter. Use list_artifact_templates first to discover workspace-scoped template ids; a template creates an independent source snapshot. Or pass template (an id from list_templates) alone to start from that template; name then defaults to the template's. Write artifacts as a complete HTML document — that is the default and the only format to use for a new artifact. Component and Screen variants are the explicit exception: keep their maintained JSX module shape so Components can expose named React exports and Screens can import them with dokki:component/id:<resource-uuid>. Use the stable UUID form for every new component reference; legacy name slugs are compatibility-only. HTML renders directly, so it cannot fail a compile step. Put styles in a <style> tag and behaviour in a <script> tag; nothing is injected for you, so add your own CSS (or <script src='https://cdn.tailwindcss.com'></script> for Tailwind, https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js for diagrams, https://cdn.jsdelivr.net/npm/chart.js for charts). The sandbox blocks browser storage: localStorage, sessionStorage, document.cookie and indexedDB all THROW on an opaque origin, which takes the whole page down — not just the save. Artifact writes that use them are rejected. For Artifact-owned durable collaborative JSON, use await window.dokki.state.get(key?), set(key, value), delete(key), and subscribe(listener); this API persists in the Artifact Y.Doc and syncs between collaborators. Use one key per independently edited entity. Use window.dokki.presence only for ephemeral cursors, selections, and viewers. A Diagram's visible content lives in that collaborative state: use diagram_read and diagram_update for nodes and edges. Never replace a Diagram with a static HTML snapshot through artifact_update or artifact_patch. A Design is a separate spatial-design resource. Use design_read and design_update with the returned spatial_contract; preserve its collaborative source. Design it to stand on its own: it renders isolated, inheriting no theme or font, so define both light and dark yourself with prefers-color-scheme, give body an explicit background, and use semantic HTML with real keyboard focus states. JSX (a default-exported React 18 component with framer-motion, lucide-react, recharts, mermaid and Tailwind preloaded) is DEPRECATED and being retired because its compile step is unreliable. Only keep JSX when editing an artifact whose current source is already JSX, or when the user explicitly asks for a React component; never choose it for a new artifact. Live workspace data: inside the artifact, await window.dokki.readTable(resourceId) resolves to { columns: [{ id, name, type }], rows, total, truncated }. Each row is { id, [column id]: value }: keyed by COLUMN ID, never by the column's name, so resolve a column with columns.find(c => c.name === 'Revenue').id. An empty cell may be missing, and a row carries version once its table keeps row versions. At most 1000 rows come back; truncated is true when there are more, and total counts them all. await window.dokki.readDocument(resourceId) returns { title, markdown }. Both take a Dokki resource UUID, read as the current viewer, and only reach resources in the artifact's own workspace that BOTH the viewer and the artifact's author can read. Prefer this over pasting a snapshot of the data into the source when the artifact should track the table. Always handle rejection — the viewer may lack access, and it is unavailable on published pages. To change a table from the page, await window.dokki.createRow(tableId, values), updateRow(tableId, rowId, changes, { expectedVersion }?) and deleteRow(tableId, rowId, { expectedVersion }?) take the same column-id keys; create and update resolve to the stored row { id, version, ...values }. The first write to each table waits until a person who can edit that table allows this …
create_document
ChatGPTCreate a new document in a workspace with optional initial Markdown content. Or pass template (an id from list_templates) instead of content to start from that template; name then defaults to the template's.
create_folder
ChatGPTCreate a new folder in a workspace
create_table
ChatGPTCreate a new table in a workspace with optional initial columns and rows. variant "issue" creates an Issues table instead: preset columns (Key, Title, Status, Priority, Type, Owner, Project, PR, Deployment, …), a key on every row such as ENG-12, and pull requests that name a key link to its row. It takes no columns or rows. Or pass template (an id from list_templates) instead of columns to start from that template's columns, rows and view; name then defaults to the template's.
delete_resource
ChatGPTMove a document, table, page, file or folder to Trash. It disappears from the workspace for everyone; a workspace admin can restore it from Trash in Dokki.
design_read
ChatGPTRead the persisted collaborative nodes and edges of a Design. Returns state_hash and runtime_compatible; pass the hash to design_update so concurrent human edits are never overwritten, and use repair_runtime:true only when compatibility is false.
design_update
ChatGPTAtomically update a collaborative Design's nodes and edges. Call design_read first and pass its state_hash as expected_state_hash. mode=replace replaces graph state while preserving compatible source; mode=merge upserts supplied items. If runtime_compatible is false, repair_runtime:true explicitly restores Dokki's collaborative runtime in the same transaction. Shapes: rectangle, rounded, diamond, circle, ellipse, hexagon, parallelogram, database. Connection handles: top, right, bottom, left. Concurrent merges: pass expected_items and expected_source_hash from design_read. City node data supports cityKind (building/home/park/plaza/school/hospital/station/road/river/bridge) and dimensions from the spatial contract. Legacy 2D city sizes use 40-1600. Follow design_read spatial_contract for 3D metre units, footprints, courtyards, compound blocks, paths and explicit relations. Preserve spatial metadata when editing.
diagram_read
ChatGPTRead the persisted collaborative nodes and edges of a Diagram. Returns state_hash and runtime_compatible; pass the hash to diagram_update so concurrent human edits are never overwritten, and use repair_runtime:true only when compatibility is false.
diagram_update
ChatGPTAtomically update a collaborative Diagram's nodes and edges. Call diagram_read first and pass its state_hash as expected_state_hash. mode=replace replaces graph state while preserving compatible source; mode=merge upserts supplied items. If runtime_compatible is false, repair_runtime:true explicitly restores Dokki's collaborative runtime in the same transaction. Shapes: rectangle, rounded, diamond, circle, ellipse, hexagon, parallelogram, database. Connection handles: top, right, bottom, left. Concurrent merges: pass expected_items and expected_source_hash from diagram_read. City node data supports cityKind (building/home/park/plaza/school/hospital/station/road/river/bridge) and dimensions from the spatial contract. Legacy 2D city sizes use 40-1600. Follow diagram_read spatial_contract for 3D metre units, footprints, courtyards, compound blocks, paths and explicit relations. Preserve spatial metadata when editing.
doc_delete
ChatGPTDelete one or more nodes from a document. Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.
doc_insert
ChatGPTInsert nodes before or after a target node in a document. Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.
doc_read
ChatGPTRead document content in compact JSON format. Returns nodes with short IDs and portable inline markdown: resource mentions use @[Label](dokki://mention/KIND/RESOURCE_UUID), inline math uses $$latex$$, colored text uses <span style='color:#hex;background-color:…'>…</span>, and tables are rendered as markdown tables. Preserve these forms when editing. Does not open an MCP App preview; use preview_resource when a rendered inline preview is needed.
doc_replace
ChatGPTReplace one or more consecutive nodes with new content in a document. Use end_node_id to replace a range (e.g. rewriting multiple paragraphs at once). Returns a diff showing the change with surrounding context. You must call doc_read first to obtain node IDs.
doc_rewrite
ChatGPTReplace the ENTIRE document content with new nodes. Use when rewriting the whole document — bypasses doc_replace's range cap and does not require first/last node IDs. Does NOT require a prior doc_read. Returns before/after node counts.
grep_workspace
ChatGPTFind an EXACT string or regex pattern across the user's documents, tables, and artifacts. Returns line-level matches with surrounding excerpts (think: grep / ripgrep over their notes). SCOPE: searches workspaces authorized for this MCP connection by default. Pass workspace_id only to restrict to one. COVERAGE: - documents → markdown content - tables → CSV of cell values - artifacts → TSX source Each hit returns kind (which follow-up tool to use: doc_read / table_read / artifact_read), workspace_id + workspace_name (which workspace the hit lives in), and url (absolute in-app URL — cite hits as markdown links [title](url), never raw IDs). A hit also carries tags and metadata when the resource has them (absent means none) — read them before citing, e.g. skip a hit tagged superseded. WHEN to use: - User asks for an exact phrase, quote, code identifier, or error message ("find the line that says ...") - You need to verify whether something specific appears verbatim somewhere - Looking for occurrences of a name, ID, URL, function, table cell value, etc. DO NOT use for: - Conceptual / paraphrased queries → use search_workspace (semantic) - Listing files → use list_resources - External / web facts → use search_web PATTERN TIPS: - Default is plain substring (case-insensitive). Set regex:true for full regex. - Return value highlights matches with [match]…[/match] tokens around hits. - A hit's match_count tells you how many total occurrences exist in that resource; excerpts are capped per hit. - coverage.complete tells you whether the scan actually covered everything. Only treat 0 hits as "this text does not exist" when it is true; otherwise read coverage.note and narrow the search instead.
list_artifact_templates
ChatGPTList reusable Artifact templates in a workspace. Returns metadata only, never template source. Each result includes variant (null, diagram, design, slide, component, or screen); pass the same artifact_variant when creating from a variant template. Requires admin or editor access; use the returned id with create_artifact(template_id) to create an independent snapshot.
list_resources
ChatGPTList all resources (documents, tables, folders, artifacts) in a workspace as a tree. A resource carries tags and metadata when it has them, and omits the field when it does not — so absence means unmarked. Pinned resources are highlighted with is_pinned=true and listed separately — prioritize reading them first. Includes a short head preview by default; set head=0 or preview_head=0 to omit previews. Pass filter to instead get a FLAT list of matching resources. Big workspace? Browse level by level: pass depth (and parent_id to descend); nodes at the cut carry child_count + children_not_loaded.
list_templates
ChatGPTList the templates a document, table or artifact can be created from: Dokki's own (meeting notes, product spec, sales pipeline, roadmap, diagram, …) and the ones the person and their team saved in the Template Center. Returns ids and summaries, never template content. Pass an id as template to create_document / create_table / create_artifact. With workspace_id, that workspace's team templates and saved artifact templates are included.
list_workspaces
ChatGPTList all workspaces the authenticated user is a member of
mindmap_add_child
ChatGPTAdd one child node with a text label under an existing mind map node.
mindmap_read
ChatGPTRead a Mind map: its outline (Markdown), nodes (id, text, parent, collapsed, tone, optional source pointer), layout, links and the state_hash mindmap_update requires.
mindmap_rename_node
ChatGPTChange one mind map node's text and clear its linked transcript excerpt, if any. If the resource name follows the central topic, renaming that topic also renames the resource.
move_resource
ChatGPTMove a resource under a new parent — a folder or a page — or to the workspace root, within its own workspace. To relocate it into another workspace, copy_resource it there and then delete the original.
preview_resource
ChatGPTOpen an interactive inline preview (MCP App) of a document, table, form, or artifact.
read_resource_metadata
ChatGPTRead a resource's current metadata and metadata revision before making a safe incremental update. Requires edit access; viewers cannot use this tool.
related_entities
ChatGPTExplore the user's Dokki knowledge graph: the people, organizations, concepts, places, and products across their workspace and how they connect. Returns matched entities (with type + document count), their neighbors (connected entities with relationship + strength), and the resources mentioning them (clickable links). SCOPE: workspaces authorized for this MCP connection by default. Pass workspace_id to restrict. WHEN to use: - 'How are X and Y connected/related?' - 'What do we know about <person/company/project>?' — its neighborhood, not just docs - Mapping relationships, org structure, or how topics interconnect DO NOT use for: finding a document's content (use search_workspace) or exact strings (use grep_workspace).
search_workspace
ChatGPTSearch the user's Dokki documents, tables, artifacts, and forms by content (hybrid search). FIRST-CHOICE tool for grounding answers in the user's own content. Each result carries type (document/table/artifact/form), resource_id, workspace_id + workspace_name (which workspace the hit lives in), and url (absolute in-app URL — cite hits as markdown links [title](url), never raw IDs). A hit also carries tags and metadata when the resource has them (absent means none) — read them before citing, e.g. skip a hit tagged superseded. SCOPE: searches workspaces authorized for this MCP connection by default. Pass workspace_id only to restrict to one. WHEN to use: - User asks about something they wrote / saved before - Answer should reference their docs rather than general knowledge - Looking for facts, decisions, or numbers buried in their workspace DO NOT use for: - Listing what files exist (use a directory/listing tool) - Reading a specific known document by id - External / current-events facts QUERY TIPS: Combine entity names with topical keywords. Bare names give narrow results. Bad: 'Aurora' Good: 'Project Aurora architecture decisions timeline' The response includes provider-neutral retrieval arm status/count diagnostics and a degraded flag. A failed optional arm is never presented as successful retrieval.
share_resource
ChatGPTShare a document, table, page, file or folder with a person by email as viewer, commenter or editor, or set its link access, which can make it readable by anyone with the link. Requires admin on the resource's workspace.
slides_add_page
ChatGPTInsert one HTML slide into an existing native Slide deck, at the end by default. Dokki assigns a new slide ID.
slides_read
ChatGPTRead a native Slide deck: slides, elements (z-order, bottom first), theme and state_hash for slides_update. Elements are absolutely positioned on the deck canvas (default 1920×1080). Prefer add_slides with a layout over placing pixels.
slides_replace_page
ChatGPTReplace the content of one existing native slide with one HTML section at its current position.
table_add_columns
ChatGPTAdd one or more columns to a table.
table_add_rows
ChatGPTAdd one or more rows to a table. Each row can have optional initial values and insertion index. Values are keyed by column ID (short prefix or full UUID) or header name.
table_delete_columns
ChatGPTDelete one or more columns from a table. Also removes all data in those columns from all rows. Supports short UUID prefix IDs from compact format.
table_delete_rows
ChatGPTDelete one or more rows from a table by their row IDs. Supports short 8-char prefix IDs from compact format, and an Issues table's keys (ENG-12).
table_metric
ChatGPTCompute a metric from a metric dictionary table: the dictionary's definition decides the source tables, filters and arithmetic. Returns rows of group keys and value, or every variant of a metric that is not approved, with provenance.
table_read
ChatGPTRead the current table data including columns and rows. Does not open an MCP App preview; use preview_resource when a rendered inline preview is needed.
table_update_cells
ChatGPTUpdate the values of one or more cells in a table. Supports short IDs from compact format (e.g. row '0a2b', column 'c1').
table_update_columns
ChatGPTUpdate properties (header name, type, width) of one or more columns.
table_upsert_rows
ChatGPTWrite rows by key: a row whose key columns already hold the same values is updated (only the cells that differ), every other row is added. Safe to repeat. Rows tables only. Values are keyed by column ID or header name.
tag_resource
ChatGPTAdd one or more tags to a resource (document, table, folder, or artifact) by tag name. Tags that don't exist are returned in not_found; pass create_missing: true to create and apply them in the same call.
untag_resource
ChatGPTRemove one or more tags from a resource by tag name
update_resource
ChatGPTRename a document, table, page, file or folder, or change its icon. metadata replaces the resource's whole metadata object; metadata_patch changes only the keys it names.