add_component_batches
ChatGPTPlace complete component batches on 2–20 pages concurrently. MCP normalizes and lints every page before any write, then sends one atomic ToolJet component request per page in parallel. Use add_components for one page. Cross-page bindings may use unique client_ref aliases declared in this batch; existing runtime names take precedence. Cross-page creation is not transactional because ToolJet has no multi-page component endpoint; an upstream partial failure names the completed and failed pages so it can be repaired in place. For properties/styles/validation with an FX toggle, use { value: <expression>, fxActive: true } only for bindings/conditions/calculations the normal control cannot express. Keep defaults and panel-editable constants (including {{true}}/{{false}}, numbers, selections, colors) out of FX. For nested Table columns/buttons/options and KeyValuePair fields, add the property key (e.g. columnVisibility, disableButton, fieldVisibility, isEditable) to that object's fxActiveFields, preserving other entries.
add_components
ChatGPTPlace MANY components on one page in a single call (all share app_id/version_id/page_id). Prefer this over repeated add_component when building an app — it is one request. Returns [{ component_id, name }]. Note: the batch is atomic — if one component is invalid (e.g. missing name), the whole call fails; fix that component and retry. Property/style/validation/other leaves may be supplied as concise raw values or canonical { value: ... } envelopes; MCP persists the canonical ToolJet shape. For properties/styles/validation with an FX toggle, use { value: <expression>, fxActive: true } only for bindings/conditions/calculations the normal control cannot express. Keep defaults and panel-editable constants (including {{true}}/{{false}}, numbers, selections, colors) out of FX. For nested Table columns/buttons/options and KeyValuePair fields, add the property key (e.g. columnVisibility, disableButton, fieldVisibility, isEditable) to that object's fxActiveFields, preserving other entries. IMPORTANT: put native styling (textSize, fontWeight, textColor, backgroundColor, borderRadius, …) in each component’s top-level styles object, NOT under properties — ToolJet silently ignores styles nested in properties (and this tool will reject them). Provide either layout (one rectangle for both resolutions) or layouts:{desktop,mobile}. To create a modal/container and its children atomically, give the parent a unique client_ref and each child the matching parent_ref; child bindings may also use unique client_ref aliases declared in this batch; MCP resolves them to runtime names when existing names can be checked, without overriding an existing runtime name. coordinates are relative to that parent, with a fresh 43-column grid in each nested canvas. A full-row child uses width 43 even in a narrow parent. Container/Form/modal slots may use left 2, width 39 for insets; grid-mode Listview full rows use left 0, width 43. For ModalV2/Form/Container native regions, set child slot_name to header, body, or footer; body is the default. A Kanban with no explicit child automatically gets its catalog card children so cards are not blank; supplying a child with its parent_ref suppresses those defaults (use Html for wrapped multi-line card content). For the Kanban card-click modal, parent its detail controls to the Kanban with slot_name:"modal"; these do not replace card children.
add_events
ChatGPTWire interactivity and lifecycle behavior to components, data queries, pages, or Table sub-elements. Each event uses { source_id, source_type: 'component'|'data_query'|'page'|'table_column', trigger, action }; component_id remains a shorthand for component sources. trigger is the component's event id (Button: 'onClick'; Table: 'onRowClicked'/'onSearch'/'onPageChanged'). For a modern Table Button column use source_id='<table id>', source_type='table_column', ref='<column key or name>::<button id>', trigger='onClick'. For a Navigation item use source_type='component', trigger='onClick', ref='<non-group menu item id>'; other ordinary components cannot use ref. Dynamic menu membership is reported as unverified. The legacy source_type='table_action' is accepted for existing deprecated properties.actions buttons only; do not use it for new apps. Query lifecycle triggers are 'onDataQuerySuccess' and 'onDataQueryFailure'; page load is 'onPageLoad'. action is { actionId, ...params } — use these EXACT ids (an invalid actionId silently does nothing): • run a query: { actionId: 'run-query', queryId: '<id>', queryName: '<name>' } • switch page: { actionId: 'switch-page', pageId: '<target page id>' } • show alert: { actionId: 'show-alert', message: '...', alertType: 'success'|'info'|'warning'|'error' } • show/close modal: { actionId: 'show-modal', modal: '<id>' } / { actionId: 'close-modal', modal: '<id>' } • set a custom variable: { actionId: 'set-custom-variable', key: 'selectedRow', value: '{{components.<table>.selectedRow}}' } (id is set-custom-variable, NOT set-variable; read back as {{variables.selectedRow}}) • control a component: { actionId: 'control-component', componentId: '<id>', componentSpecificActionHandle: '<get_component_catalog actions.handle>', componentSpecificActionParams: [{handle:'<required param>',value:'...'}] } (use [] for parameterless actions) • reset/change a Table page: { actionId: 'set-table-page', table: '<Table component id>', pageIndex: '{{1}}' } • other valid ids: unset-custom-variable, set-page-variable, copy-to-clipboard, generate-file, open-webpage, go-to-app, logout. generate-file CSV/plaintext works; PDF expects pre-formed PDF bytes and does not perform conversion. For reliable mutations, let the submit/click event run only the mutation; attach refresh, success alert, reset/close actions to the mutation's onDataQuerySuccess and an error alert to onDataQueryFailure. For master→detail, order handlers as set-custom-variable → optional run-query → switch-page. Navigation MUST be last because later same-trigger handlers do not run; a runOnPageLoad detail query does NOT re-run on page switch. Create all of an app's events in one call. MCP validates source existence, component-specific triggers, Table Button-column refs, action ids, and action targets before writing.
add_pages
ChatGPTAdd multiple pages to an app in one call. Names/handles are preflighted together, page order follows the input order, and sidebar icon/hidden metadata is persisted and verified with one final readback. Every page requires a relevant Tabler icon; set hidden:true for detail pages reached only through navigation. Returns {pages}. ToolJet has no page bulk transaction: a rare partial failure names every persisted page; do not retry the whole batch or auto-delete those pages.
add_queries
ChatGPTSave query definitions in the ToolJet app editor; this is an authoring operation. It never executes the SQL, code, API requests, or datasource operations described by options. Options are stored configuration for later app use, not commands invoked during this call. Create MANY queries in a single call (all share version_id). Prefer this over repeated add_query when building an app. Each query names its own datasource_id and options. Call get_datasource_query_schema for the operations you use before constructing those options. The batch resolves datasource kinds once, contract-validates every query before any writes, and returns {queries,warnings,validation}. ToolJet has no query bulk transaction: a rare partial failure names every persisted query; do not retry the whole batch. Creates are serialized per version within this MCP client. Optional client_ref aliases declared in this batch are resolved in its query bindings/RunJS when unambiguous; existing runtime names take precedence.
add_query_lifecycles
ChatGPTCreate standard mutation success/failure behavior for many queries in one call. For each query, declare refresh_query_ids, clear_component_ids, close_modal_id, success_alert, and/or failure_alert; MCP expands them into normal ordered ToolJet events, validates every source/target/action, then performs one bulk event write. Optional success_actions/failure_actions accept ordinary event action objects for uncommon extras. before_refresh_actions are dispatched before refresh_query_ids; success_actions remain after them. This is ordering, not a transaction or async completion guarantee: chain dependent writes via success events and refresh only after the final write. Use add_events for other ordering. This helper is datasource-neutral.
add_table_column
ChatGPTAdd one column to an existing ToolJet DB table without recreating it. Supports the same type aliases, constraints, default/configuration metadata, and optional foreign-key shape as create_table. Read the current schema with get_table_schema first. Existing rows must be compatible with non-null/default constraints.
apply_app_phase
ChatGPTApply one app-authoring plan, whose operations are also exposed as rename_app, create_tables, insert_rows_batch, add_pages/update_pages/delete_page, add_queries/update_query, add_components/update_components/delete_components, update_layout, add_events/update_events/delete_event, and add_query_lifecycles. Saving a query or event definition does not execute it. The optional read check described below is the only query execution in this tool. Consume one successful lint_app_spec plan_token and apply that exact phase once. The tool resolves logical refs, creates tables/pages/queries in dependency order, seeds rows, creates independent page component batches concurrently, combines ordinary events and mutation lifecycles into one bulk write, then returns persisted structural/contract validation. It then runs the proven read queries the phase created or updated once and reports them in read_check (failed: fix the query; inconclusive: the read takes a component value a browser-free run leaves empty; not_run: writes, remote or paid calls and RunJS, which are never run here). A failing read does not fail the phase. ToolJet has no cross-resource transaction: a rare upstream partial failure reports the completed stage/counts and never auto-deletes user data, except for a plan page marked replace: that page ends up holding exactly the plan's components. It is written as a difference: a component the plan leaves as it is is not rewritten, one that only moved is moved, one that changed is created again under its own id, and one the plan drops is deleted, with the events on the page's components replaced by the plan's (page events and query events only where the plan declares them again); queries the plan defines again are updated in place keeping their ids. A replace is refused before any write if the page changed since lint (any component, redefined query or related event edited), and every component and event ref is prepared before the first write. A replace is not atomic: a failure midway leaves the page to be repaired (the result says what was removed; there is no rollback), so use replace on draft or otherwise recoverable pages. The one-time token prevents an accidental retry from duplicating objects.
apply_workflow_spec
ChatGPTApply a validated authoring plan to an editable draft and verify readback. Saves node/edge configuration, creates or updates the associated query definitions, removes explicitly deleted graph objects and their obsolete queries, and optionally saves test parameters. Does not execute node code, send datasource requests, run the workflow, or publish. The same authoring actions are individually exposed as upsert_workflow_<type>_node, upsert_workflow_edge, delete_workflow_edge, delete_workflow_node, and set_workflow_test_parameters. Partial writes return IDs for recovery; never blindly retry creation.
archive_workspace_user
ChatGPTArchive the exact member of the pinned workspace and revoke their workspace access. Requires confirm:true, workspace_users OAuth scope, and ToolJet permissions.
clear_app_resource_permission
ChatGPTRemove a resource access restriction, broadening access to every user who can access the app. Requires confirm:true after explicit approval of this exact page, query, or component.
create_app
ChatGPTCreate a new ToolJet app with a first version and home page. Returns app_id, version_id, home_page_id, editor_url, viewer_url, datasources_url, app_url (a backward-compatible alias for editor_url), and the theme that was applied. Honor explicit or selected themes first. Otherwise derive a theme from a brand, industry or customer type (see references/themes.md) and pass theme:{name, definition}; include complete brand, text, border, systemStatus and surface tokens with light/dark values, not a font-only or partial definition. It is created once per workspace by name and applied. Otherwise the app gets the standard theme ("ToolJet Modern": neutral greys, hairline borders, 8/6/12 radii, blue primary). Pass theme:"workspace_default" to leave the app on the workspace default, or an existing theme name/id to reuse one. No theme is ever set as the workspace default. If a theme cannot be created (for example a licence gate) the app is still created and the result carries a theme warning.
create_app_version
ChatGPTCreate a new draft version of an existing ToolJet app by cloning a specified source version. Returns the app_id, new version_id, version_name, source_version_id, and available version metadata; Conflicts fail without adopting an existing draft, including after a timeout. Before editing, inspect the returned version_id for its cloned resource IDs. The agent and ToolJet editor automatically switch to the newly created version after success. Version names must be unique within the app.
create_tables
ChatGPTCreate multiple ToolJet-DB tables in one call. The complete batch is preflighted before writes for duplicate/reserved names, foreign-key column mistakes, and circular dependencies. Tables are then created in dependency order, with independent tables created in batches of at most four; a failed batch stops further creation. Returns {tables}. ToolJet has no atomic multi-table endpoint: if an upstream request fails, the error names any tables already created; MCP never deletes them automatically.
create_workflow
ChatGPTCreate an editable ToolJet workflow draft. Does not execute, publish, or configure triggers. Inspect get_workflow before adding its start node.
create_workspace_group
ChatGPTCreate an empty custom group in the pinned workspace. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
create_workspace_group_access
ChatGPTCreate a granular group access rule for the selected resource type. access requires name, is_all, and actions; selected-resource rules also need resource_ids from list_workspace_groups. Omitted action switches are disabled. App actions: canEdit/canView/hideFromDashboard/canAccessDevelopment/canAccessStaging/canAccessProduction/canAccessReleased; module: canEdit/canView/hideFromDashboard; workflow: canEdit/canView; data_source: canConfigure/canUse. canEdit/canView and canConfigure/canUse are exclusive pairs; enabling one disables the other. is_all:true includes current and future resources. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
create_workspace_theme
ChatGPTCreate a custom workspace theme, or reuse an existing active theme of the same name. Supply a name of at least five characters and a full definition for a new theme. is_default can replace the workspace default. With both app_id and version_id, applies it to that app and selects dark mode for a dark light-mode canvas. License gates apply.
delete_app_version
ChatGPTDelete the explicitly selected, unreleased version only on an explicit user deletion request. List versions first and provide a different fallback_version_id in the same app for the editor to open afterward. Never delete the released or only version. Do not retry an uncertain deletion automatically.
delete_components
ChatGPTPermanently remove named components from one page. Inspect the targets and obtain explicit approval, then pass confirm:true. The tool refuses surviving child components, component/query bindings, and external events that still reference a target. It verifies every requested id disappeared and never deletes dependencies automatically.
delete_event
ChatGPTDelete one event handler by id (from list_events). Use this to remove wiring that points at a deleted component/query, or to drop an action you added by mistake.
delete_page
ChatGPTPermanently delete one non-Home page and its components. This is destructive: inspect the target, obtain explicit user approval for the named page, then pass confirm:true. The tool refuses pages still targeted by events outside that page, because ToolJet does not safely retarget those references. Group-wide deletion is disabled because ToolJet does not return a verifiable child-page deletion set; delete each inspected and approved page separately.
delete_query
ChatGPTPermanently delete one query. Inspect the target and obtain explicit approval, then pass app_id and confirm:true. The tool refuses component bindings, dependent query bindings, and external events that still reference it, verifies the query disappeared, and never deletes dependencies automatically.
delete_workflow_edge
ChatGPTRemove one explicitly selected edge from an editable workflow draft, including control-flow or agent attachment edges. Preserves all nodes and their queries, so removing an attachment leaves its model/tool node and query in place and may leave the draft unready. To remove a connected agent model and its query together, use upsert_workflow_agent_node with model:null instead. Never executes the graph. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
delete_workflow_node
ChatGPTDelete one workflow node and all incident edges. Saves the graph before deleting a query only when no remaining mapping references it. Incomplete drafts can be cleaned up; remaining runtime blockers are returned. Does not execute or publish. A failed query deletion leaves only an orphaned query; inspect the returned recovery details before retrying.
delete_workspace_group
ChatGPTDelete an existing custom group, including its memberships and permissions. Cannot delete default groups. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
delete_workspace_group_access
ChatGPTDelete a granular access rule belonging to this group. Read rule IDs with list_workspace_groups include_permissions:true. Optional resource_type must match. Read-only rules cannot be deleted. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
delete_workspace_theme
ChatGPTDelete an existing workspace theme only after explicit approval of that exact theme. Requires confirm:true. ToolJet permissions and license gates apply.
drop_table
ChatGPTPermanently drop a ToolJet DB table and all its rows. This is destructive. Inspect dependent queries/components, obtain explicit user approval for the named table, then pass confirm:true in that same approved operation.
drop_table_column
ChatGPTPermanently drop a ToolJet DB column and its stored values. This is destructive. Inspect the schema and query/component bindings first, obtain explicit user approval, then pass confirm:true in that same approved operation.
duplicate_workspace_group
ChatGPTDuplicate a group with selected categories: permissions, members, apps, modules, workflows, or data_sources. At least one copy flag must be true; omitted flags are false. ToolJet assigns the copy name. Copying members and permissions can grant access through the new group. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
generate_edit_contract
ChatGPTGenerate opt-in raw-record snapshot, native field defaults/change events, and changed-field-only RunJS payload preparation for an edit workflow. Preserves untouched fields; explicitly nullable fields can be cleared. No API calls, writes, layout choices or inferred business rules. Supply existing query/component names and merge returned artifacts into a linted phase; wire the datasource mutation separately using the returned guarded ID/patch contract.
generate_form_schema
ChatGPTGenerate a ready-to-place ToolJet Form property block from an existing ToolJet DB table only when every selected field maps to textinput, number, emailinput, password, datepicker, or checkbox. Mixed schemas needing dropdown, multiselect, textarea, radio, toggle, starrating, or filepicker are rejected with the standalone-component workaround because FormUtils cannot render them with clean, controllable alignment.
get_app
ChatGPTFetch the FULL raw ToolJet app by id (pages, versions, every component with its complete widget schema). This is large (100KB+ for a real app) — for routine inspection prefer get_app_summary, which returns the same structure with actual values only. Use get_app only when you need raw fields the summary omits.
get_app_resource_permission
ChatGPTRead server-enforced access for one page, query, or component belonging to the selected app. Use exact resource IDs from get_app_summary.
get_app_settings
ChatGPTRead the current editing version's compact app-wide visual settings: canvas background/width/mode, selected theme, header/logo/title, and navigation visibility/layout. Use before update_app_settings; this omits theme definitions and other large raw app data. Set include_libraries for bounded, read-only JavaScript library configuration and RunJS scope guidance before authoring library-dependent queries; this never loads or executes code.
get_app_summary
ChatGPTSelective, bounded inspection of an app — use this instead of get_app. Pass version_id after create_app_version to inspect that exact version instead of the server's default editing version. By default detail="structure" returns page/component/query/event identity and layout but omits bulky component values, query options, and event payloads. Filter by page/component/query/event ids or names and select exact top-level or dotted fields, e.g. component_fields:["id","properties.data.value","styles.textSize.value"]. Use detail="full" only after narrowing the target. Each component value is the ACTUAL bound value, never the full widget schema. Field roots: app(app_id/name/version_id), page(id/name/handle/icon/hidden/index/is_page_group/page_group_id), component(id/name/type/layouts/properties/styles/validation/others/parent), query(id/name/kind/data_source_id/options), and event(id/name/sourceId/target/event). sections can omit pages/queries/events; include_components:false returns page metadata only.
get_component
ChatGPTFetch ONE placed component by id — its actual bound values only: { id, name, type, page_id, layouts, properties, styles, validation, others }. Includes actual native input validation. Cheaper than get_app_summary when you only need to inspect or diff a single component before update_component.
get_component_catalog
ChatGPTDiscover ToolJet components. With no type(s), returns the lightweight palette. Use type for one component or types for a batch needed in the current page/phase. Typed reads default to detail:"compact" and the overview/properties/events/actions sections; compact property/style lists omit labels and defaults. Use detail:"full" or exact property_keys/style_keys only when those values are needed. Request renderingHints/authoringHints for layout-sensitive or nested components. Use requests when different types need different sections/keys in one call; top-level detail/sections/keys apply as defaults to every requested type, and the type/types/requests selectors may be combined. sections selects only overview, properties, styles, events, actions, exposedVariables, defaultChildren, renderingHints, and/or authoringHints; property_keys/style_keys narrow those arrays further. A batch returns {components,unknown_types}. GridView is a lookup alias for Listview mode:"grid"; component writes must still use type:"Listview". authoringHints covers nested contracts such as ModalV2 native slots, Table row-action Button columns, and Form JSON-schema field types. Fetch complex/unfamiliar contracts once and reuse them; never guess property/event/action ids.
get_datasource_endpoint_schema
ChatGPTRead the request contract for one API endpoint from its specification; never send the endpoint request. Uses the fixed getEndpointSchema metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
get_datasource_query_schema
ChatGPTRead datasource authoring metadata from the bundled catalog. This tool never invokes a datasource operation, creates a query, or executes SQL/API requests. Get compact, operation-specific request contracts plus response shape/status when known. Unknown and runtime-dependent responses are labelled explicitly so callers know when a safe run or remote schema is still required. Call with no selector for the datasource palette; select by kind, or by datasource_id + version_id to resolve the kind automatically. Pass operation to avoid loading unrelated branches. sections defaults to summary/request/response for one operation; request raw plugin UI metadata only for diagnostics. requests batches up to 10 contracts; any top-level fields (kind/datasource_id/version_id/operation/sections) act as defaults for every entry, so mixing top-level and requests is fine.
get_runtime_info
ChatGPTReturn the loaded ToolJet MCP version/build identity and whether its on-disk runtime changed after process start. If restart_required is true, restart or reload the MCP/plugin host before using any other tool.
get_table_schema
ChatGPTGet a ToolJet-DB table's columns, including primary/not-null/unique constraints, defaults, configurations, and foreign-key relationships. Use before building queries, columns, forms, or filters on an existing table, or to verify a table you just created.
get_workflow
ChatGPTRead a workflow graph and query options. Use returned node IDs as existing_id when editing. Omitted version selects the current editing version, which may be read-only.
get_workflow_capabilities
ChatGPTList authorable workflow node types and classify configured datasource instances for one workflow version: ordinary query, AI-model attachment, or email. Reads workflow metadata and the configured datasource list only; it does not invoke the listed capabilities. After choosing a datasource, call get_datasource_query_schema with datasource_id + version_id + operation for its exact query fields, allowed operations, response shape, and introspection methods. Does not inspect credentials, create resources, or execute queries.
get_workflow_execution
ChatGPTInspect execution status and a bounded page of node results. Does not start or retry executions.
get_workflow_node_catalog
ChatGPTSupported workflow node types, ports and exact authoring schema. Unsupported native nodes are preserved, not authored.
insert_rows_batch
ChatGPTSeed multiple ToolJet-DB tables in one call. Entries are processed in the listed order so parent rows can be inserted before foreign-key children. Writes are insert-only: omit generated serial keys; explicit duplicate keys fail rather than updating rows. Returns {tables:[{table_name,processed_rows}],processed_rows}. A partial failure reports completed table/row counts; do not retry completed seeds. Keep initial demo data representative and small; each table payload is capped at 40 rows so large fixtures must be split across compact calls.
inspect_datasource_schema
ChatGPTInvoke one read-only metadata method advertised by a connected datasource plugin (for example listSchemas, listTables, listColumns, or listCollections). This avoids creating/running ad-hoc information_schema queries. HubSpot: call listTables without schema to list spec groups, then pass schema for endpoint discovery. Use get_datasource_query_schema with sections:["introspection"] to discover exact methods. Common schema/table/search/page/limit inputs are converted to ToolJet selector args; args adds plugin-specific fields. Only the requested metadata method is called. Use requests (up to 20) to batch independent table/column lookups after the schema/table names are known; every method is validated before any invocation. Individually exposed operations: list_datasource_datasets, list_datasource_tables, list_datasource_columns, list_datasource_sheets, list_datasource_spreadsheets, get_datasource_endpoint_schema, list_datasource_collections, list_datasource_schemas, list_datasource_tenants.
invite_workspace_user
ChatGPTSend an email invitation to the pinned workspace. Requires confirm:true for the exact recipient and access. Role defaults to end-user; optional group_ids add existing custom groups. Requires workspace_users OAuth scope and ToolJet permissions. Do not automatically retry an uncertain send.
lint_app_spec
ChatGPTValidate a proposed app definition and return diagnostics plus a temporary plan token. Reads existing app/schema metadata only; does not apply the proposal, execute embedded SQL/code, invoke datasource operations, or call the mutations described by the proposal. Dry-run an exact app phase before any writes. It validates optional ToolJet DB tables/seed_data, datasource queries, pages/components, events, and concise query lifecycles together. Give pages, queries, and components stable client_ref values; events use source_ref and targeted actions use target_ref. A query can use table_ref to resolve a planned/existing ToolJet DB table by its actual table_name into options.table_id (not a client_ref or alias). For each query use either the exact datasource_id or the exact unique datasource_name from list_datasources(version_id); names are pinned to IDs during this preflight, never guessed from kind. Set app_name when the target app should be renamed in the same governed phase. For repair/continuation phases, pass app_id so persisted page/component/query refs are included and can be targeted without redeclaring them. To rebuild an existing page whole, mark its plan page replace: true (with app_id): the plan is checked against the app with that page emptied, the page's own queries may be defined again (updated in place on apply), and a component another page, event or query still reads must be kept under its name. A Form submits through a Button inside it: set the Form's properties.buttonToSubmit to that Button's client_ref in the same plan (resolved to its id on apply). On success it returns a one-time 30-minute plan_token for apply_app_phase. Treat this call as an awaited barrier; it never mutates ToolJet. For properties/styles/validation with an FX toggle, use { value: <expression>, fxActive: true } only for bindings/conditions/calculations the normal control cannot express. Keep defaults and panel-editable constants (including {{true}}/{{false}}, numbers, selections, colors) out of FX. For nested Table columns/buttons/options and KeyValuePair fields, add the property key (e.g. columnVisibility, disableButton, fieldVisibility, isEditable) to that object's fxActiveFields, preserving other entries.
lint_workflow_spec
ChatGPTValidate graph edits, query options, and runtime prerequisites without executing or saving the workflow. Reads graph/query/datasource metadata, compiles proposed configuration, and checks JavaScript syntax without evaluating it. Does not run nodes, invoke their datasource operations, or apply graph edits. Returns a scoped temporary one-use plan token when runnable, or for an editable draft only when allow_draft is true. Omitted nodes/edges are preserved; removals require explicit IDs.
list_app_permission_subjects
ChatGPTList users and groups eligible for resource access rules in one app. Subjects must already have app access. ToolJet permissions and license gates apply.
list_app_themes
ChatGPTList compact workspace themes available for app settings. Disabled themes are returned but cannot be selected by update_app_settings. Theme definitions are intentionally omitted to keep discovery small.
list_app_versions
ChatGPTList exact versions and environments for one app. Use returned IDs to resolve named lifecycle targets; never infer IDs.
list_datasource_collections
ChatGPTList collection names in a connected document datasource. Uses the fixed listCollections metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_columns
ChatGPTRead column definitions for one datasource table. Uses the fixed listColumns metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_datasets
ChatGPTList dataset names in a connected datasource. Uses the fixed listDatasets metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_schemas
ChatGPTList database schema names in a connected datasource. Uses the fixed listSchemas metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_sheets
ChatGPTList sheets in a connected spreadsheet datasource. Uses the fixed getSheets metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_spreadsheets
ChatGPTList spreadsheets available to a connected datasource. Uses the fixed getSpreadsheets metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_tables
ChatGPTList tables or API endpoint paths from a connected datasource; for HubSpot, an omitted schema lists spec groups. Uses the fixed listTables metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasource_tenants
ChatGPTList tenant metadata available through a connected datasource. Uses the fixed getTenants metadata method, only when the datasource advertises it. Does not execute saved queries, author resources, or invoke the API endpoints described by a returned schema. schema/table/search/page/limit are selectors; args supplies datasource-specific selectors such as spreadsheet ID or endpoint HTTP method.
list_datasources
ChatGPTList AI-eligible workspace-connected datasources. The shared Sample data source is excluded and must never be used by AI. Includes the built-in ToolJet-DB datasource (kind 'tooljetdb') to use as the datasource_id for add_query. These sources appear automatically in both existing and newly created apps; there is no per-app attach/link step. If an expected source is absent, check workspace, permissions, connection, and environment configuration. Each returned source includes settings_url for user-assisted connection repair; never enter credentials or save changes for the user. Returns {datasources, connectable}: datasources are the connected ones (use their id for add_queries), connectable names every source ToolJet CAN connect. A source the user named that is in connectable but not in datasources needs connecting; one in neither has no ToolJet connector and has to go through a REST API datasource pointed at its HTTP API. Pass the actual app version_id: for a new app, create_app must return it before this call.
list_events
ChatGPTList event handlers for a version, optionally filtered to one source (component/query id). Returns [{ id, name, index, event, sourceId, target }] where event is the { eventId(trigger), ref?, actionId, ...params } blob. target may be component, data_query, page, table_column, or legacy table_action. Table Button columns use ref=<column key or name>::<button id>. Use the ids with update_events / delete_event to fix or remove wiring without rebuilding.
list_tables
ChatGPTList the ToolJet-DB tables in the workspace as { tables: [{ id, table_name }], total, shown }. A ToolJet-DB (tooljetdb) query's options require the table's id as table_id (NOT the table name) — call this to resolve a table name to its id before add_query. Pass search (a case-insensitive substring, usually the app's table prefix) so a busy workspace does not return hundreds of unrelated tables; at most limit rows come back (default 100).
list_workflows
ChatGPTList workflows in the active workspace.
list_workspace_apps
ChatGPTList front-end apps in the workspace pinned to the current ToolJet connection, with pagination, app-name search, and optional folder_id filtering. Discover folder IDs with list_workspace_folders. Each app includes folders: [{id,name}] (empty when unfiled). The top-level folder describes the selected folder, or is null. meta.workspace_folder_count counts visible app folders; meta.folder_app_count counts matching apps in the selected folder (null without a folder filter). meta.total_count remains the workspace-wide count of matching apps even with folder_id; use meta.folder_app_count for the folder. This cannot inspect or switch to another workspace.
list_workspace_folders
ChatGPTList visible front-end app folders in the workspace pinned to the current ToolJet connection. Returns folders: [{id,name,app_count}] and meta.total_count (matching folders). app_count counts apps visible to you. search_text filters folder names, not app names. Includes empty folders when ToolJet permits you to see them. Pass a returned id as folder_id to list_workspace_apps to read that folder’s apps with pagination and app-name search. OAuth connections require the apps scope; existing ToolJet permissions still apply.
list_workspace_groups
ChatGPTList groups in the workspace pinned to the current connection. OAuth connections require the workspace_users scope. Supply group_id to list its non-archived members with group_user_id (membership id, distinct from user_id and organization_user_id). Use include_permissions:true with group_id to read permission switches and granular access rules. Use resource_type (app/module/workflow/data_source) to discover selectable resources and their names/IDs. Use exact returned ids for group changes. Requires ToolJet admin permissions.
list_workspace_themes
ChatGPTRead workspace themes with id, name, and flags. Unlike list_app_themes, this also supports include_definitions:true for all definitions or theme_id for one full definition. Does not change themes.
list_workspace_users
ChatGPTList users in the workspace pinned to the current ToolJet connection. Supports pagination, search, and status filtering. OAuth connections require the workspace_users scope.
list_workspaces
ChatGPTList the ToolJet workspaces (organizations) this user belongs to: [{ id, name, slug, datasources_url, is_default, is_current }]. datasources_url opens ToolJet connection management for user-assisted setup/repair. A user can be in multiple workspaces, and apps/tables/datasources are scoped to the ACTIVE one. This server is token-scoped to a single workspace, so exactly one is returned and there anything. is_current marks the active workspace.
manage_app_permissions
ChatGPTList eligible subjects, inspect, set, or clear server-enforced access for one app page, query, or component. Use list_subjects first and exact ids from get_app_summary; users/groups must already have access to the app. set restricts access to the selected users or groups. clear broadens access to every user who can access the app. Mutations require confirm:true after the user explicitly requests the exact access rule. ToolJet license gates still apply. Individually exposed operations: list_app_permission_subjects, get_app_resource_permission, set_app_resource_permission, clear_app_resource_permission.
manage_theme
ChatGPTManage workspace theme objects through ToolJet's typed theme API. Actions: list, create, set_default, update_definition, rename, delete. Definitions contain brand, text, border, systemStatus, and surface tokens with light/dark values. create with app_id and version_id also applies the theme to that app (in dark mode when its light-mode canvas is dark), so a new app needs no update_app_settings call; create reuses a theme of the same name, so there is no need to list themes first. Delete requires confirm:true after exact-target approval. list returns id, name and flags only; pass include_definitions:true (or theme_id) to get a definition. Individually exposed operations: list_workspace_themes, create_workspace_theme, set_default_workspace_theme, update_workspace_theme_definition, rename_workspace_theme, delete_workspace_theme.
manage_workspace_groups
ChatGPTCreate, rename, delete custom groups or remove a member in the workspace pinned to the current connection. OAuth connections require the workspace_users scope. All actions require confirm:true after reviewing the exact change. create needs name; rename needs group_id and name; delete needs group_id; remove_member needs group_id and group_user_id from list_workspace_groups. Removing membership does not delete the workspace user. Deleting a group removes its memberships and permissions. duplicate needs group_id and at least one true copy flag (permissions/members/apps/modules/workflows/data_sources; omitted flags false); ToolJet assigns the copy name. update_permissions needs group_id and permissions (only supplied switches change). create_access needs group_id, resource_type and access {name,is_all,actions,resource_ids}; update_access needs group_id, rule_id and access (only supplied fields change); delete_access needs group_id and rule_id. For update/delete access, optional resource_type must match the existing rule. Read include_permissions:true first to resolve rule IDs; resource_type discovers selectable resource IDs. On update_access, use access.add_resource_ids/remove_resource_ids to change only those resources and preserve the rest. access.resource_ids is only for an explicitly requested replacement of the entire rule selection; do not combine it with add/remove_resource_ids. Resource additions/removals require a selected-resource rule; is_all:true applies to ALL current and future resources of its type. On create_access, omitted action switches are disabled. App actions: canEdit/canView/hideFromDashboard/canAccessDevelopment/canAccessStaging/canAccessProduction/canAccessReleased. Module actions: canEdit/canView/hideFromDashboard. Workflow actions: canEdit/canView. Data source actions: canConfigure/canUse. canEdit/canView and canConfigure/canUse are exclusive pairs: enabling one disables the other, including on partial updates. Disabled groups and read_only rules are not editable under the current license/plan. allow_role_change is only for permission updates and access updates, and only with explicit consent to change affected member roles. Admin permissions cannot be changed; default group names/memberships cannot be changed here. To add members use manage_workspace_users with group_ids. ToolJet admin and license checks apply. Individually exposed operations: create_workspace_group, rename_workspace_group, delete_workspace_group, remove_workspace_group_member, duplicate_workspace_group, update_workspace_group_permissions, create_workspace_group_access, update_workspace_group_access, delete_workspace_group_access.
manage_workspace_users
ChatGPTManage users only in the workspace pinned to the current ToolJet connection. OAuth connections require the workspace_users scope. Invite, update, archive, and unarchive require confirm:true. Updates can change role, add existing custom group_ids while preserving all other memberships, and merge supplied user_metadata keys while preserving other keys. Empty group_ids never removes groups. first_name/last_name are only supported for invitations: editing an existing name requires a Super Admin in ToolJet and is refused by this workspace-scoped tool before any mutation. Updates are read back before success is reported. Use manage_workspace_groups remove_member for explicit membership removal. Updates cannot change email or passwords. Changing a role to end-user also transfers any apps owned by that user to the acting admin under ToolJet's existing behavior; disclose this before confirmation. Invite accepts email, optional names/role/group_ids; archive/unarchive accepts only organization_user_id. Never substitute role or membership changes for a rejected name edit, or bypass the connection owner's ToolJet permissions. Individually exposed operations: invite_workspace_user, update_workspace_user, archive_workspace_user, unarchive_workspace_user.
prepare_sql_discovery_queries
ChatGPTPrepare—but do not create or run—read-only SQL query specs for a connected SQL datasource. Produces add_queries-compatible count, explicit-column bounded preview/distinct, and verified metadata queries for primary keys, foreign keys, indexes, and views where the dialect is curated. It never emits SELECT *; preview/distinct limits are hard-capped at 100. Add the returned specs in one add_queries call, then use run_query under its count/large/billable-read safeguards.
promote_app_version
ChatGPTSave a draft if necessary and promote the selected version only as far as the explicitly requested environment. Never releases the app. Pass confirm:true only for an explicit promotion request. Returns verified editor selection metadata.
release_app
ChatGPTRelease a specific ToolJet app version so it becomes the app's live released version. Use only when the user explicitly asked to release or publish the app, and pass confirm:true. The operation publishes a draft when necessary and promotes it one environment at a time until it reaches production when the workspace requires it, then releases only that exact version. It is safe to retry after a transient preparation failure. Returns a verified current_version_id after reading the app back.
remove_workspace_group_member
ChatGPTRemove one membership from a custom group without deleting the workspace user. group_user_id is the membership ID returned by list_workspace_groups, not a user ID; membership must belong to this group. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
rename_app
ChatGPTRename one existing app through its editable version. Uses the same preflight, name-collision handling, scoped one-use plan, and readback as apply_app_phase, with no table, page, query, component, or event edits. Returns the persisted app result; does not execute queries.
rename_workspace_group
ChatGPTRename an existing custom group. Default group names cannot be changed. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
rename_workspace_theme
ChatGPTReplace the name of an existing workspace theme. Requires a theme_id from the active workspace; ToolJet permissions and license gates apply.
run_queries
ChatGPTRun 1–10 already-created, proven read-only queries concurrently and return ordered per-query results. It currently accepts ToolJet DB list_rows/join_tables and SQL datasource list_rows or one bounded explicit-column SELECT/SHOW/DESCRIBE/EXPLAIN read. Every query is preflighted before any execution; SELECT *, unbounded reads, mutations, RunJS, paid/remote API operations, and unknown kinds are refused — remote API reads (restapi, openapi, servicenow, influxdb) can never run here; use singular run_query with user_confirmed_remote_read. Metadata and the environment are loaded once. Returns {queries:[{query_id,name,status,data|message,warnings?}]}; one runtime failure does not hide other read results. Pass include_data:false to only confirm each query runs — the result drops the rows and returns {status,row_count} instead, for lightweight post-build verification. Use singular run_query with count_query_id for a count-first large-read preflight. Component-bound options receive the run_query viewer warning.
run_query
ChatGPTExecute only a saved query that passes the server's proven-read checks. Mutations, arbitrary RunJS, unknown datasource kinds, and SELECT are refused before execution. No operation or query-options payload can be supplied to this tool; it reads the selected saved definition and applies its safety checks. Run an already-created query and return its REAL result — the browser-free way to see actual data. Use it to (a) verify a query works before binding UI to it, and (b) inspect real column values / distinct values (statuses, categories) before writing chart series, dropdown options, or filters. The query must already exist (create it with add_query first). Returns { status: "ok"|"failed", data: <datasource result>, ... }; data may be an array or an object (ToolJet DB SQL uses data.results). Inspect the actual shape before binding components. HTTP is 200 even on failure, so CHECK `status` and read `message` on failure. Runs the SAVED query as-is; it does not mutate it. SELECT is always refused. Reads with no static limit at or below 1000 rows require an unfiltered, same-datasource count_query_id first; if the observed count is larger, retry only after explicit user approval with user_confirmed_large_read:true. BigQuery, Snowflake, and Redshift reads also require explicit cost approval with user_confirmed_billable_read:true, even when row-limited. Never set confirmation flags from inferred consent. A static remote read (including REST GET and Supabase rows) requires separate approval with user_confirmed_remote_read:true because it may expose sensitive data or consume quota; remote writes are refused. If saved options reference components.*, the result includes a warning because browser-free execution cannot prove the component-resolved pagination/filter behavior.
run_workflow
ChatGPTStart one execution of an existing saved ToolJet workflow version in the selected environment, passing its input data in params. This calls the workflow-run API; params are workflow data, not an operation selector or executable graph. The saved workflow itself can perform datasource writes, send requests, and execute arbitrary code, so authorize that workflow and its effects before calling. This tool does not author or modify the workflow, publish it, or enable a disabled workflow. Never automatically retry a timeout: execution may have completed.
set_app_resource_permission
ChatGPTReplace access to one app page, query, or component with selected users or groups. Supply user_ids for access_type users or group_ids for groups, never both. Requires confirm:true after explicit approval of the exact rule; existing app access and license gates still apply.
set_default_workspace_theme
ChatGPTChange whether an existing workspace theme is the default. is_default defaults to true; false removes its default status. Changes the workspace default used by apps.
set_workflow_test_parameters
ChatGPTReplace the saved default test parameters of an editable workflow draft. Saves data only; does not start a test or execute the workflow. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
switch_app_environment
ChatGPTOpen the same app version in a requested environment without publishing, promoting, or releasing it. Fails if that version is not available there. Use only for an explicit environment-switch request.
switch_app_version
ChatGPTSelect an existing ToolJet app version as the version the current editor should open and subsequent agent edits should target. Use only when the user explicitly asks to switch, select, open, or work on that version. This does not publish or release the version. Returns verified version and environment metadata that the ToolJet client uses to switch the editor.
test_datasource_connection
ChatGPTRun ToolJet's own connection test for one ALREADY-CONNECTED datasource — the same check the datasource settings page performs. Uses the datasource's stored credentials; you never supply, see, or need them. Use it to distinguish a broken connection from a wrong query when a run fails, or to confirm a source before building on it. Returns supported:false for datasource kinds whose plugin does not implement a connection test (REST API, GraphQL, and most OAuth/HTTP integrations) — that is not a fault and says nothing about the connection. On a real failure, hand the returned settings_url to the user for repair; never enter credentials or save settings for them.
unarchive_workspace_user
ChatGPTRestore an archived member to active status in the pinned workspace. Requires confirm:true, workspace_users OAuth scope, and ToolJet permissions.
update_app_settings
ChatGPTPatch app-wide visual settings on the current editing version in one version update, then read them back. Supports canvas background/width/mode, a theme selected from list_app_themes, header/logo/title, and navigation visibility/layout. hide_header controls the app header/banner. The separate generated page-navigation menu can be positioned on the side or top; navigation_hidden hides that entire menu in either position. To hide only one non-Home page from that menu, use update_pages.hidden. Omitted fields are preserved. Every requested field is read back; the tool returns an error instead of success if any field did not persist.
update_app_version
ChatGPTRename the selected version or edit its description, only when explicitly requested. Does not publish, promote, or release. Backend version permissions and edit restrictions apply.
update_components
ChatGPTEdit existing components IN PLACE instead of deleting + re-adding. Send only the CHANGED leaves under definition (properties/styles/validation/others) — ToolJet deep-merges, so untouched values are preserved. Leaves may be raw values or { value: ... } envelopes; MCP canonicalizes them. For properties/styles/validation with an FX toggle, use { value: <expression>, fxActive: true } only for bindings/conditions/calculations the normal control cannot express. Keep defaults and panel-editable constants (including {{true}}/{{false}}, numbers, selections, colors) out of FX. For nested Table columns/buttons/options and KeyValuePair fields, add the property key (e.g. columnVisibility, disableButton, fieldVisibility, isEditable) to that object's fxActiveFields, preserving other entries. Updates must include both value and fxActive; revert with { value: <constant>, fxActive: false }. For nested Table fields, remove only reverted property keys from fxActiveFields. KeyValuePair arrays merge by index; verify flag removals and report retained flags. NOTE: array values (Table columns, DropdownV2 options/schema) are REPLACED wholesale, so send the full array. Set EITHER definition OR name/parent/slot_name per entry, not both. slot_name accepts header/body/footer and can move a child between native ModalV2/Form/Container regions, or modal for Kanban card-click content; omit parent to keep the current parent. Unknown entry keys are rejected (a top-level properties/styles patch is an error, not a silent no-op), and an entry that changes nothing fails. Get component ids + current values from get_app_summary / get_component.
update_events
ChatGPTEdit existing event handlers (batch) — e.g. change an action or its params — instead of deleting and re-adding. For updateType "update" you MUST include name and the full event blob ({ eventId, actionId, ...params }) per entry (name becomes null if omitted). For "reorder" only index is used. Get event ids from list_events. Outer event_id identifies the saved handler; inner event.eventId is its trigger name (for example "onClick"), NOT the saved handler id.
update_layout
ChatGPTMove / resize existing components (batch) without touching their properties. left/width are in the immediate parent canvas's own 43-column grid, including nested containers; top/height are pixels. Full rows use width 43, independent of the parent outer width. Container/Form/modal insets may use left 2, width 39; grid-mode Listview full rows use left 0, width 43. Provide desktop and/or mobile per component. Use this to fix overlaps or reflow a page. Set parent to reparent; use slot_name (header/body/footer) for native ModalV2/Form/Container regions or modal for Kanban card-click content. slot_name alone keeps the current parent.
update_pages
ChatGPTUpdate existing page sidebar metadata and/or reorder pages, with one final readback verification. Use updates to rename pages, set a relevant Tabler icon, or toggle one non-Home page in the menu. The Home page can be renamed, restyled, and reordered, but cannot be hidden. To hide or show the entire generated navigation menu, use update_app_settings.navigation_hidden instead. Use order only with the complete ordered list of every current page id (available from create_app/get_app_summary); partial orders are rejected to prevent duplicate indexes.
update_query
ChatGPTEdit a stored query definition in the ToolJet app editor. Does not execute its SQL, code, API request, or datasource operation; options are saved configuration for later app use. Change an existing query in place. options REPLACES the stored options wholesale — send the FULL options object, not a partial. Pass app_id so the existing query kind is resolved and options are validated. To repoint a query, also pass datasource_id; validation happens before the datasource changes, and MCP attempts to roll back the source if the subsequent option update fails. The query toggles (runOnPageLoad, runOnDependencyChange, requestConfirmation, showSuccessNotification) must be true or false on every call.
update_workspace_group_access
ChatGPTUpdate an existing rule belonging to this group; read IDs with list_workspace_groups include_permissions:true. Only supplied fields change. add_resource_ids/remove_resource_ids preserve other selections and require a selected-resource rule; do not combine with resource_ids or is_all. resource_ids replaces the entire selection. Optional resource_type must match the rule. allow_role_change needs explicit role-change consent. App actions: canEdit/canView/hideFromDashboard/canAccessDevelopment/canAccessStaging/canAccessProduction/canAccessReleased; module: canEdit/canView/hideFromDashboard; workflow: canEdit/canView; data_source: canConfigure/canUse. canEdit/canView and canConfigure/canUse are exclusive pairs; enabling one disables the other. is_all:true includes current and future resources. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
update_workspace_group_permissions
ChatGPTUpdate only supplied permission switches on a group. Admin permissions cannot be changed. allow_role_change requires explicit consent to change affected member roles. Requires confirm:true for the exact change, workspace_users OAuth scope, and ToolJet admin permissions. License restrictions apply.
update_workspace_theme_definition
ChatGPTReplace the full token definition of an existing workspace theme, affecting apps using it. Definitions require brand, text, border, systemStatus, and surface tokens with light/dark colors. License gates apply.
update_workspace_user
ChatGPTChange a workspace member role, add custom group memberships, or merge supplied metadata keys. Preserves other memberships and metadata; empty group_ids removes nothing. Changing role to end-user transfers owned apps to the acting admin: disclose before confirm:true. Cannot change names, email, or passwords. Requires workspace_users scope and ToolJet permissions; reads back updates.
upsert_workflow_agent_node
ChatGPTCreate or edit one agent node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Omitting model preserves its existing attachment. Setting model:null removes the connected model node, attachment edge, and associated query; the agent remains in the draft without a model. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_condition_node
ChatGPTCreate or edit one condition node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_edge
ChatGPTCreate or edit one control-flow edge in an editable workflow draft. Use existing node IDs for from/to; existing_id edits an edge. Never executes the graph. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_javascript_node
ChatGPTCreate or edit one javascript node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_loop_node
ChatGPTCreate or edit one loop node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_query_node
ChatGPTCreate or edit one query node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_response_node
ChatGPTCreate or edit one response node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
upsert_workflow_start_node
ChatGPTCreate or edit one start node in an editable workflow draft. Existing_id edits the same node; omission creates a node. Stores configuration and any associated query definition without executing its code or datasource operation. Uses the same scoped planning, validation, one-use token, partial-write reporting, and readback as apply_workflow_spec. allow_draft defaults true so an incomplete draft can be edited.
use_workspace
ChatGPTConfirm the ACTIVE workspace (organization). This server is scoped to a single workspace by its connection credentials and cannot switch: passing that workspace id returns it, and any other id errors naming the one in use. Everything is created in that workspace, so there is nothing to select at setup — call list_workspaces if you need its id, name, slug or datasources_url.
validate_app
ChatGPTValidate persisted app structure and saved query contracts WITHOUT executing queries or opening a browser. Pass version_id after create_app_version to validate that exact version. Returns an explicit checked/not_checked scope plus { ok, errors, warnings }. Catches: dangling event references (event on a deleted component/query, run-query pointing at a missing query), ambiguous duplicate component/query names, bindings to non-existent queries/components ({{queries.X}} / {{components.X}} with no such X), and per-component render traps (Table bound without rawJson, malformed DropdownV2 options, invalid static Chart JSON, Chart left with its clipping default title, bad headerCasing). Run it before you call the app done (then still do the one browser pass). errors are broken references or invalid persisted contracts you should fix; warnings are likely render problems worth checking. A clean result does NOT prove external APIs, mutations, event delivery, or visual rendering work; run explicitly selected safe reads and browser-test primary flows.
validate_workflow
ChatGPTCheck persisted graph structure and query ownership without execution. Does not prove runtime correctness.
add_component_batches
Claudeadd_components
Claudeadd_events
Claudeadd_pages
Claudeadd_queries
Claudeadd_query_lifecycles
Claudeadd_table_column
Claudeapply_app_phase
Claudeapply_workflow_spec
Claudearchive_workspace_user
Claudecancel_workflow_approval
Claudeclear_app_resource_permission
Claudecode_app_add_dependency
Claudecode_app_build
Claudecode_app_data
Claudecode_app_install
Claudecode_app_read_files
Claudecode_app_scaffold
Claudecode_app_write_files
Claudecreate_app
Claudecreate_app_version
Claudecreate_tables
Claudecreate_workflow
Claudecreate_workflow_schedule
Claudecreate_workspace_group
Claudecreate_workspace_group_access
Claudecreate_workspace_theme
Claudedelete_app_version
Claudedelete_components
Claudedelete_event
Claudedelete_page
Claudedelete_query
Claudedelete_workflow_edge
Claudedelete_workflow_node
Claudedelete_workflow_schedule
Claudedelete_workspace_group
Claudedelete_workspace_group_access
Claudedelete_workspace_theme
Claudedrop_table
Claudedrop_table_column
Claudeduplicate_workspace_group
Claudegenerate_edit_contract
Claudegenerate_form_schema
Claudeget_app
Claudeget_app_resource_permission
Claudeget_app_settings
Claudeget_app_summary
Claudeget_component
Claudeget_component_catalog
Claudeget_datasource_endpoint_schema
Claudeget_datasource_query_schema
Claudeget_runtime_info
Claudeget_table_schema
Claudeget_workflow
Claudeget_workflow_approval
Claudeget_workflow_bundle_status
Claudeget_workflow_capabilities
Claudeget_workflow_execution
Claudeget_workflow_execution_states
Claudeget_workflow_node_catalog
Claudeget_workflow_package
Claudeget_workflow_packages
Claudeget_workflow_schedule
Claudeget_workflow_webhook
Claudeinsert_rows_batch
Claudeinspect_datasource_schema
Claudeinvite_workspace_user
Claudelint_app_spec
Claudelint_workflow_spec
Claudelist_app_permission_queries
Claudelist_app_permission_screens
Claudelist_app_permission_subjects
Claudelist_app_themes
Claudelist_app_versions
Claudelist_datasource_collections
Claudelist_datasource_columns
Claudelist_datasource_datasets
Claudelist_datasource_schemas
Claudelist_datasource_sheets
Claudelist_datasource_spreadsheets
Claudelist_datasource_tables
Claudelist_datasource_tenants
Claudelist_datasources
Claudelist_events
Claudelist_tables
Claudelist_upcoming_workflow_runs
Claudelist_workflow_approvals
Claudelist_workflow_consumers
Claudelist_workflow_executions
Claudelist_workflow_schedules
Claudelist_workflows
Claudelist_workspace_apps
Claudelist_workspace_branches
Claudelist_workspace_folders
Claudelist_workspace_groups
Claudelist_workspace_themes
Claudelist_workspace_users
Claudelist_workspaces
Claudemanage_app_permissions
Claudemanage_theme
Claudemanage_workspace_groups
Claudemanage_workspace_users
Claudeprepare_sql_discovery_queries
Claudepreview_workflow_node
Claudepromote_app_version
Clauderebuild_workflow_bundle
Clauderelease_app
Clauderemove_workspace_group_member
Clauderename_app
Clauderename_workspace_group
Clauderename_workspace_theme
Clauderesolve_workflow_approval
Clauderun_queries
Clauderun_query
Clauderun_workflow
Claudesearch_workflow_packages
Claudeset_app_resource_permission
Claudeset_default_workspace_theme
Claudeset_workflow_inputs
Claudeset_workflow_packages
Claudeset_workflow_schedule_active
Claudeset_workflow_setup_script
Claudeset_workflow_test_parameters
Claudeset_workflow_webhook_enabled
Claudeset_workflow_webhook_parameters
Claudestop_workflow_execution
Claudeswitch_app_environment
Claudeswitch_app_version
Claudetest_datasource_connection
Claudeunarchive_workspace_user
Claudeupdate_app_settings
Claudeupdate_app_version
Claudeupdate_components
Claudeupdate_events
Claudeupdate_layout
Claudeupdate_pages
Claudeupdate_query
Claudeupdate_workflow_schedule
Claudeupdate_workspace_group_access
Claudeupdate_workspace_group_permissions
Claudeupdate_workspace_theme_definition
Claudeupdate_workspace_user
Claudeupsert_workflow_agent_node
Claudeupsert_workflow_agent_tool
Claudeupsert_workflow_condition_node
Claudeupsert_workflow_edge
Claudeupsert_workflow_filter_node
Claudeupsert_workflow_human_node
Claudeupsert_workflow_javascript_node
Claudeupsert_workflow_loop_node
Claudeupsert_workflow_query_node
Claudeupsert_workflow_response_node
Claudeupsert_workflow_start_node
Claudeupsert_workflow_wait_node
Claudeuse_workspace
Claudevalidate_app
Claudevalidate_workflow
Claudewatch_workflow_execution
Claude