MCP App Store
by KeenEthics

Overview

Softr is an AI app builder that turns your data into apps, portals, and automations. This connector gives ChatGPT direct access to your Softr workspace, so you can go from an idea to a working, published app in a single conversation. Databases: create tables and the fields to match your project, structure and import records, and browse data sources you have already connected. Applications: generate an app on top of your data, add and arrange pages and blocks, configure sign-up and login, set user groups and page permissions, and manage app users. Extend any page with a custom code block that ChatGPT writes for you, with every version saved so you can roll back. Workflows: build multi-step automations with triggers, actions, and branching logic, test each step against real data, and publish when it works. ChatGPT can preview the result and, when you ask it to, publish live. Everything it makes appears in Softr Studio exactly like work done by hand, so you and your team keep editing in the visual builder afterward - nothing is locked into the chat. Day to day, ChatGPT can also work with your data directly: search, filter, and aggregate records, and create or update them in bulk. Every action runs with your own permissions, and you choose the access level per workspace when you connect: read-only, edit, or full access.

Tools

ai_list_models

ChatGPT
The most recent models of each provider Softr's AI runs, for a vibe-coding application's AI features. Each entry has the id the generated code names in defineAiAction({ model }) to run it on Softr's own keys and the workspace's AI credits, its provider, its name, bestFor, what to pick it for, reads, what it reads beside text (such as IMAGE), and reasoning, whether it thinks before it answers. Call this before writing an AI feature and copy an id exactly; one spelled from memory is never in the list. Pick by bestFor: a chat, a summary or a briefing takes the strongest model, an extraction or a classification over one document the cheapest that reads that document's kind. For a feature the user runs on their OWN OpenAI, Anthropic or Gemini account, the same list gives providerModelId: the id that provider's API accepts, sent in the request body of the proxied call. The call itself goes through the connected integration, see application_get_integration_proxy_target.

application_add_user

ChatGPT
Add an end-user to an application (a user of the published app, not a builder/collaborator). Both name and email are required. Returns the created user: id, email, name, applicationId and timestamps. Fails if a user with this email already exists in the app. Use application_list first to find valid application IDs.

application_apply_pattern

ChatGPT
Write a page or component from a pattern into a code application, filled in for one datasource and its fields, as one checkpoint. Returns the path it wrote, what it left for you to finish, and the file as written. It refuses to overwrite an existing file unless the arguments set "overwrite": true, which replaces that file. Take the arguments from application_list_patterns with the pattern's name.

application_call_server_function

ChatGPT
Test a server function you wrote in a code application: run it in the app's preview the way the app's page runs it, and get its result. Use it before you tell the user a feature works, to check that the server code you wrote with application_write_files or application_edit_file does what you meant. It runs only code from this app's own source files, under the function's own permission rules, and reaches nothing that code does not. It runs signed out unless you pass asUserEmail, an app user's email (application_add_user adds one): the function then runs as that user, with their user groups and data restrictions, as when they use the page. file is the source file under src/ that exports the function, as the route files import it, for example src/server/requests.ts, and exportName its exported name. data is the input the page passes, which the function's own validator checks; leave it out for a function that takes none. A test run is not a dry run. Its effects are real, as in the app: the records the function creates, changes or deletes, and any workflow it starts, which may send email. Use test values a person would recognise as a test, test a function that changes data only to check the change you built, and remove what the test created when the check is done. Answers {ok: true, value} with what the function returned, or {ok: false, error} with what it threw, such as its validator's message or a refused permission.

application_check

ChatGPT
Check a code application the way Softr checks its own agent's work. It first regenerates the app's types and the data-model docs from the live tables, then runs the type checker, the linter and the route file parser, and collects the runtime errors the dev server and the browser logged since your last write. Fix everything it reports. Call it after every feature and after every data-model change.

application_configure_email_sender

ChatGPT
Configure the email sender for an application: the name and address the app's emails (invites, magic links, notifications) are sent from. Which fields you pass selects the mode: - email + name: register the sender on the workspace (or rename an existing one) and assign it to this app. Needs workspace-wide write access and a plan with custom senders. - email only: assign an EXISTING workspace sender to this app (use workspace_list_email_senders to see them; fails if none matches). App-level write access is enough for this. - neither: reset the app to the default Softr sender (its subdomain @softr.app address). Whichever mode you use REPLACES the app's current sender, and the previous one is not kept. IMPORTANT: registering a new sender triggers a verification email to the address, which cannot be undone once sent, and the response's confirmed field is the source of truth. While confirmed=false the app KEEPS sending from the default Softr sender — tell the user the sender is pending confirmation and that someone with access to that mailbox must click the confirmation link; do not report the sender as active. A sender on a custom domain also needs DKIM and Return-Path DNS records so receiving servers trust its mail: the response lists them in dnsRecords (dkim and returnPath), with domainVerified false until they are verified. Give them to the user, then check them with workspace_verify_email_sender. Use application_list to find application IDs.

application_configure_sign_in

ChatGPT
Set how end users sign in to an application: turn the email method or the permanent login link on or off, and set the email method's options. Omit a setting to keep its current value, but pass at least one. Returns the resulting login object, the same shape application_get returns, so you can report the result without reading the application again. - emailEnabled: the EMAIL sign-in method. - permanentLoginLinkEnabled: the MAGIC_LINK method — a link that signs a user in without a password and keeps working. Anyone who gets hold of a user's link can sign in as them, so before turning it on, tell the user that and get their explicit go-ahead. - emailLoginMethods: how the email method checks a user — ["PASSWORD"], ["EMAIL_CODE"] (a one-time code sent by email) or both, in which case a user can use either. Passing a single method also turns off a two-factor setup (twoFactor in application_get). One-time codes need a paid plan; on other plans the call fails with a payment-required error. - strongPasswords: require at least 12 characters with upper and lower case, a number and a symbol. - emailCodeExpiration: how long a one-time code is valid: 1_MINUTE, 2_MINUTES, 5_MINUTES (the default), 10_MINUTES or 30_MINUTES. Turning a method off locks out the users who sign in that way, and narrowing the email login methods stops users from signing in the way they are used to, so confirm either with the user first. At least one sign-in method must stay on: a change that would leave none fails with a conflict error. Google sign-in and SSO cannot be changed here: they need credentials from Google or the customer's identity provider, which the user enters in the Softr Studio UI. Give the user the googleSettingsUrl or ssoSettingsUrl link from the result or from application_get instead. Do not ask the user to paste those secrets into the chat. Two-factor sign-in with an authenticator app is not set here either: give the user the authenticatorAppSettingsUrl link. On an error, relay it rather than reporting the setting as changed. Only applies to apps that support login; studio-api rejects apps without login settings. Use application_list to find application IDs.

application_configure_sign_up

ChatGPT
Configure end-user sign-up for an application. The policy you pass REPLACES the current one, and narrowing it withdraws sign-up from people who could register a moment ago: DISABLED stops everyone, DOMAIN_RESTRICTED stops every address outside allowedDomains. Confirm either move with the user before calling it. Set policy to one of: - DISABLED: no one can sign up - OPEN_TO_PUBLIC: anyone can sign up - DOMAIN_RESTRICTED: only people whose email is in allowedDomains can sign up (requires allowedDomains) allowedDomains is a list of email domains like ["example.com"]; it is used only with DOMAIN_RESTRICTED and ignored for the other policies. Returns the applicationId, the resulting policy and allowedDomains. Only applies to apps that support login/sign-up; studio-api rejects apps without login settings. Use application_list to find application IDs.

application_configure_user_sessions

ChatGPT
Set when end users of an application are logged out. sessionExpiration is how long a login lasts: 24_HOURS, 7_DAYS, 30_DAYS or 90_DAYS (the default). inactivityTimeout logs a user out after a period without activity: 5_MINUTES, 15_MINUTES, 30_MINUTES, 1_HOUR, 3_HOURS or NEVER (the default). Pass the values exactly as written here. Omit either to keep its current value, but pass at least one. A value you pass replaces the current one. Returns both resulting values. Shorter values make users log in more often, so confirm them with the user first. Values other than the defaults need a paid plan with advanced security; on other plans the call fails with a payment-required error, so relay it rather than reporting the setting as changed. Only applies to apps that support login; studio-api rejects apps without login settings. Use application_list to find application IDs.

application_create

ChatGPT
Create a new blank application (app) and return its details: generated id, name, workspaceId, applicationType, home page id and timestamps. The app starts blank with a default home page and is NOT published — use application_publish when the user wants it live, and application_preview to look at it first. Optionally pass workspaceId to choose which workspace the app is created in; omit it to use the user's default workspace. Use workspace_list to resolve a workspace name to an ID if needed. Optionally pass name to set the app's name; omit it to let Softr auto-generate one.

application_create_user_connection

ChatGPT
Connect an existing table as the one that authenticates an application's end users, and map which of its fields hold the email, name and the rest. Use this when application_get_user_connection comes back empty (source null, fields []) — that is the app having no users table, which is what blocks condition-based user groups. It reports empty rather than failing, so do not wait for an error. Returns the connected table and its fields in exactly the shape application_get_user_connection returns, so you can name what you connected and build a condition from the result without calling application_get_user_connection afterwards. Connects a table that already exists; it does not create one. Browse to it first and take the IDs from those calls rather than guessing any of them: integration_list → integration_list_databases → integration_list_tables → integration_list_table_fields for the fields and their fieldReferenceKey. For SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP there is a level in between: call integration_list_schemas and pass schema. Every other type has no schema level and REJECTS schema. Pass databaseName and tableName as well as the IDs, or the app's users settings show the connected table blank. Only emailFieldId is required — an end user is identified by their email address. nameFieldId and avatarFieldId are worth mapping whenever the table has them, since the app shows both. Every mapping references a field by the table's fieldReferenceKey from integration_list_table_fields: the field's id when it is "id", the field's name when it is "name" - "id" for SOFTR_TABLES, SMARTSUITE, CLICKUP, MONDAY, CODA, HUBSPOT, SALESFORCE and ZOHO_CRM, "name" for every other type. The user sync reads records by that value, so a mapping in the other key, one that names no field, or a field whose type cannot hold the value is rejected with the reason; re-read the fields rather than retrying. IMPORTANT: if the application ALREADY authenticates against a table, this fails with a 409 and replaceExisting is NOT the fix. Re-pointing an app at a different table does not move its existing users across — they stay in the old table and can no longer sign in. The 409 names the table that is connected: quote it to the user, say what they would lose, and set replaceExisting only after they say to. The 409 message is enough on its own — application_get_user_connection reports the same table under source.table, but calling it costs a slow live read to learn what you were just told. Never set replaceExisting on your own judgement, and never merely because the call was refused. Connecting REQUESTS a user sync — the thing that turns the table's rows into application users — but one only runs if two-way user sync is on for the app. Apps have it on from creation; it is off only where someone paused it. So do not assume the users arrived. Check userSyncStarted: false means the table is connected and NO rows were imported. When it is false userSyncStatus carries a sentence saying why and what fixes it — relay that rather than reporting success; the fix is usually the app's users settings, not another call to this tool. When a sync IS running userSyncStatus is null, because there is nothing to report beyond the flag. Connecting the table does not switch end-user login on: application_set_login does that, and application_configure_sign_up controls who may sign up. Say so rather than reporting the app as ready for users. Reads the live datasource once before it writes, so it is slow and fails when the integration is unreachable or the table is gone. Every check runs before the write, so a call that fails changed nothing and the app still has whatever users table it had — relay the reason as it is, since a bad field mapping, an unsupported source type and an unreachable datasource need different responses.

application_create_user_group

ChatGPT
Create a custom end-user access-control user group on an application (the groups that gate what app users can see and do). Returns the created group: id, name, type, userEmails, condition and order. A group is one of two kinds and never both: - manual: pass userEmails, an explicit list of app-user email addresses - condition-based: pass condition, a rule evaluated against each app user's own record Passing both fails with a 400; passing neither creates an empty manual group you can fill in later. The condition's shape, which the schema advertises only as an object: {"logicalOperator": "AND", "expressions": [{"subject": {"field": "USER:<field reference>", "type": "ARRAY"}, "operator": "IS", "value": ["<choice reference>"]}]} logicalOperator is AND or OR and defaults to AND. Build it by calling application_get_user_connection first: subject.field must be "USER:<field reference>" naming a real field from that call by its fieldReferenceKey - the field's id when that is "id", its name when that is "name" - and never a guess: a reference in the other key is refused naming the value to send, and one that matches no field at all is refused too, so neither reaches a group. The predefined "USER:EMAIL" and "USER:EMAIL_DOMAIN" work without a lookup. subject.type is TEXT, ARRAY, NUMERIC, DATE or BOOLEAN, chosen as application_get_user_connection describes; for an ARRAY field the value entries are that field's choices by the same key - choice ids when fieldReferenceKey is "id", labels when it is "name". value is ALWAYS a list of strings, whatever subject.type is: a single-select Role compared as TEXT still sends ["<choice reference>"], never a bare "<choice reference>". A scalar fails JSON binding before any validation runs and comes back as a 400 that names no property, so there is nothing to relay. IMPORTANT: IS_NOT and NOT_EQUAL on an ARRAY field are rejected - they match no users at all. Use HAS_NONE_OF to exclude option values instead. How many values the operator takes is part of its contract, and a mismatch is rejected: IS_EMPTY and IS_NOT_EMPTY read the field alone and take [], BETWEEN takes exactly two (lower, upper), and every other operator takes at least one. A DATE subject compares against a structured token, never prose - "TODAY" is not a date. IS, IS_NOT, LT, GT, LTE and GTE take "PREDEFINED:TODAY" / "PREDEFINED:YESTERDAY" / "PREDEFINED:TOMORROW", "FIXED_DATE:DAYS_AGO:<n>", "FIXED_DATE:DAYS_FROM_NOW:<n>" or an exact "YYYY-MM-DD"; IS_WITHIN and IS_NOT_WITHIN take "RELATIVE_DATE:THIS:<WEEK|MONTH|QUARTER|YEAR>" or "RELATIVE_DATE:LAST:<n>" / "RELATIVE_DATE:NEXT:<n>". The two sets do not overlap, and each token's suffix is part of its grammar - THIS takes a calendar period, LAST/NEXT take a whole number of days. Names are unique within an application, case-insensitively, so call application_list_user_groups first and pick a free one rather than sending a name that is taken - the call is rejected either way, but a rejected call is a wasted turn. A blank name is also rejected, as is a create once the workspace is at its custom-user-group allowance. Relay whatever this fails with as it is, rather than reporting the group as created or retrying the same call: a name collision and an exhausted plan allowance need different responses from you. When the user names specific people for a manual group but gives no email addresses, ask for them instead of calling this - a group created without them has no members. Use application_list to find application IDs.

application_delete_data_restriction

ChatGPT
Delete a data restriction. Everything it was keeping back becomes visible and editable again for the user groups it bound, on every page and in any generated code that reads the table — so confirm with the user before calling this unless they asked for it in as many words. Removes the whole restriction, every rule in it. To drop ONE rule and keep the rest, call application_set_data_restriction with that restriction's id and the rules you want to keep. Idempotent: an id the application does not hold comes back deleted: false rather than failing, so a repeat after a timeout is safe. Restriction IDs come from application_list_data_restrictions.

application_delete_user_group

ChatGPT
Delete a custom end-user user group. Also removes its sign-in/sign-out redirections and its entries in the application's data restrictions. Returns a confirmation with the applicationId and userGroupId. Fails with a 404 if the group is not in this application, and a 409 if it is a predefined group (Logged in users, Visitors, Everyone) - only custom groups can be deleted. IMPORTANT: anything gated on this group loses that grant, and the two ways that happens differ. - Data restrictions: the group is dropped from every restriction that named it, and a restriction this group was the ONLY grantee of is removed outright. Access is default-deny, so data the application reads can become inaccessible to its users - which is how this bites an app built from code rather than from pages. - Page permissions and block or action-button visibility, where the application has them, KEEP the now-unresolvable group ID; the builder shows those as "Deleted group". Anything visible only to this group may end up reachable by nobody. So after deleting, tell the user what was gated on the group so they can re-check it. WARNING: This action cannot be undone. Confirm with the user before calling it. To change who is in a group rather than remove the group, use application_update_user_group. If the delete is refused, relay the reason as it is - a predefined group and a group from another application are different problems.

application_edit_file

ChatGPT
Replace exact text in one file of a code application. Each edit's oldText must occur exactly once, copied from your latest read of the file or from what you last wrote to it, unless replaceAll is true. All edits apply in order and land as one checkpoint; if any oldText is not found, nothing changes. Pass several edits as edits, or a single one as oldText and newText. To rewrite most of a file, use application_write_files instead.

application_get

ChatGPT
Get details of a specific application by ID: name, description, workspace, type, custom domain/subdomain, home page id, timestamps, and the configured email sender (emailSender: signatureId, name, email, confirmed, and isDefault — isDefault=true means the app sends from the default Softr address; an unconfirmed custom sender also still sends from the default one; domainVerified and dnsRecords show whether the sender domain's DKIM and Return-Path records are in place, as last checked — workspace_verify_email_sender re-checks them), and when end users are logged out (userSessions: sessionExpiration and inactivityTimeout, null for apps without login; change them with application_configure_user_sessions). Use application_list first to find valid application IDs.

application_get_access_overview

ChatGPT
Get an overview of an application's access-control configuration: the user groups plus the counts of user-group redirections, sign-up-based redirections, and data restrictions.

application_get_domain_status

ChatGPT
Check whether an application's custom domain is set up: the records it needs (dnsRecords: type, host, fqdn, value) and, for each, whether public DNS already answers with that value (live). connected is true when every record is live. Use it after the user adds the records or finishes the Entri setup (application_create_domain_setup_link), and repeat it every minute or so until connected is true: DNS changes can take minutes to hours, so a record that is not live yet is normal, not an error. connected only means DNS points at Softr. It does not mean the app is published; once connected, republish the app with the publish tool available to you and then report the domain as live. domain is empty when the application has no custom domain (connect one with application_set_domain). Use application_list to find application IDs.

application_get_integration_proxy_target

ChatGPT
Where a vibe-coding application's proxied calls to one workspace integration must go — Slack, Google Calendar, Jira, Stripe, OpenAI, Linear, Zendesk and ~50 more. Softr's proxy injects the workspace's credentials server-side, so the generated code never sees a token. Nothing is registered: the generated code names the integrationId directly. This tool only answers where the calls go. Use it for a proxied integration, and application_register_data_source for tabular data. Build every call's url from proxyBaseUrl in this tool's response — do NOT hardcode a vendor host; for Jira, Zendesk, Salesforce and DocuSign it is account-specific. Calls to any host outside the returned allowedHosts are rejected by the proxy, and for a custom API (REST_API) also calls outside proxyBaseUrl's path. Fails for an integration the proxy cannot call. Access: who may call the proxy is declared in the generated code — public or restricted, the builder's choice. Anything the credentials can do, that audience can do. Say so when it matters. Find integrationId with integration_list, which lists integrations of every kind.

application_get_logs

ChatGPT
Read the tail of a code application's dev server output: server errors, render errors and the SDK's requests to Softr. Use it when the preview misbehaves and application_check is clean.

application_get_user_connection

ChatGPT
Get the table that authenticates an application's end users, and its fields. This is the table a condition-based user group is evaluated against, so call this BEFORE building any condition for application_create_user_group or application_update_user_group — it is the only way to learn the table's real fields, and a condition naming a field this table does not have is refused rather than silently matching nobody. Returns source — where the users table lives — fieldReferenceKey, and, per field, its id, name, type, rawType, multiValued and choices. Use source whenever you have to say WHICH table an app authenticates against; the field list cannot answer that. source mirrors the browse tools, so its parts feed straight back into application_create_user_connection: dataSource {id, name, type} as integration_list returns, database {id, name} as integration_list_databases returns, schema, and table {id, name} as integration_list_tables returns. Re-pointing an app at another table in the same data source needs only source.dataSource.id — do not go searching integration_list for it. Use the name of each when telling a person what is connected; ids mean nothing to them. database and schema are null when the source has no such level (HubSpot, Salesforce, Zoho and REST API have nothing above the table; only SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP have a middle one). A null name inside a level means "not recorded", never "no table" — source.resourceIdentifier always identifies it. For Airtable, Google Sheets and SQL sources the table's id IS its name — that is what addresses a table there, and integration_list_tables reports it the same way, so the two always agree. fieldReferenceKey is "id" or "name", as integration_list_table_fields reports it, and a condition MUST use it: "USER:<reference>" holds the field's id when it is "id" and the field's name when it is "name". It is "id" for SOFTR_TABLES, SMARTSUITE, CLICKUP, MONDAY, CODA, HUBSPOT, SALESFORCE and ZOHO_CRM, and "name" for every other type - read it rather than inferring it from the list, which is longer than the handful of sources that made this worth fixing. A choice follows the same key: its id when "id", its label when "name". A field reference in the other key is refused with the value to send. A CHOICE reference is only checked when subject.type is ARRAY, so a single-select compared as TEXT takes whatever it is given: a choice id there is stored, matches nobody and reports nothing. Get the choice right yourself; do not wait to be corrected. fieldReferenceKey is null when the app has no users table at all - the empty result above, which application_create_user_connection fixes rather than a different key - and against a studio-api that predates the field, where you can still read the same key off integration_list_table_fields for the table. When the user describes membership by a value ("whose Role is a manager"), match their wording against that field's choices case-insensitively and tolerantly of singular/plural, and carry the matching choice into the condition value by that key. When exactly one choice matches, use it and proceed; ask only when several plausibly match or none do. Picking the condition's subject.type: read multiValued, NOT type. type is a normalised value with no select member and cannot tell you a field holds several values. Map it as: multiValued true → ARRAY; otherwise number → NUMERIC, date or datetime → DATE, bool → BOOLEAN, anything else → TEXT. Returns an empty result (source null, fields []) when the application has no users table at all, so condition-based groups are impossible. Never build a condition against an empty result. That state is fixable: application_create_user_connection connects a table, after which conditions work — until then, create a manual group with userEmails instead. Fails if the datasource cannot be read (an expired connection, a deleted table); in that case say so rather than guessing a field. This fetches live schema from the extern…

application_install_dependencies

ChatGPT
Install a code application's npm dependencies after you changed package.json, so the dev server and the type checker see the new packages. Takes up to a few minutes.

application_list

ChatGPT
List all applications (apps) the authenticated builder can access across their workspaces. Returns id, name, description, workspaceId, applicationType, domain/subdomain and timestamps. Use this first to discover application IDs before calling other tools. Optionally filter by workspaceId to list apps in a specific workspace only. Use workspace_list to resolve a workspace name to an ID if needed.

application_list_data_restrictions

ChatGPT
List an application's data restrictions - the rules that decide which records and fields each end-user group may see and change in a connected table. These apply on top of anything a page, a block or generated code does, so a record missing from an app that looks correctly built is explained here. Returns, per restriction: its id, the user groups it binds (id AND name, so you can name one to a person without a second call), the table it covers, and its rules. A rule reads as one sentence - "users can't view certain records", "users can only edit 2 fields in any record": - operation: VIEW, EDIT, DELETE or ADD. An operation with no rule is unrestricted for these groups. - effect: RESTRICT (they can't) or ALLOW_ONLY (they can, and nothing else) - records: ALL, or MATCHING with condition or conditionV2 naming which - fields: absent when the rule covers every field, else the field references it narrows to, by the table's fieldReferenceKey from integration_list_table_fields A MATCHING rule carries condition (flat, block-based apps) or conditionV2 (a tree, vibe-coded apps); both shapes are documented under application_set_data_restriction. Describe a tree by walking it: a group {"operator": "AND" | "OR", "conditions": [...]} reads "all of" / "any of", a leaf reads "<leftSide> <operator> <rightSide>". An older rule may carry both; conditionV2 is the one enforced. On a vibe-coded app several restrictions can cover the same table and group, and they combine: ALLOW_ONLY rules widen access (OR), and RESTRICT rules narrow it (AND). Read them together before telling the user what a group can see. A block-based app has at most one per table and group. A group whose name is null was deleted after the restriction was written; the restriction still binds its id and still applies to nobody. Worth flagging to the user - it is usually a leftover. An empty list means the application restricts nothing, which is the normal state for a fresh app.

application_list_data_sources

ChatGPT
List the datasources registered on a vibe-coding application — an application with no pages and no blocks, whose generated code addresses everything through this application-level registry instead of block connections. Returns each entry's datasourceId (the id the application's code references), name, integrationId, type and resource identifier keys. Only works for vibe-coding applications; for a regular (block-based) application, data is wired per block instead — see vibe_coding_block_get_code's dataSources.

application_list_files

ChatGPT
List every file of a code application that you can read and write, with its uncommitted status.

application_list_icons

ChatGPT
List the icon names an application's navigation items can use (kebab-case Untitled UI names such as "home-01" or "users-plus"). Call it once before choosing icons for application_navigation_create or application_navigation_set_items, and reuse the list for the rest of the conversation. A name outside this list is replaced by a generic icon.

application_list_patterns

ChatGPT
List the page and component patterns of code applications, or describe one in full: its roles, every argument application_apply_pattern takes for it, and what it leaves for you to finish. When a guide skill says to start from a pattern, start here.

application_list_user_groups

ChatGPT
List the end-user access-control user groups defined on an application (the groups that gate what app users can see and do). Returns, per group, its id, name, type (PREDEFINED/CUSTOM), member emails, condition and order. A group is manual or condition-based, never both: a manual one carries member emails and a null condition, a condition-based one carries a condition and no emails. Read this before calling application_update_user_group, whose userEmails and condition each REPLACE what the group held rather than merging into it — so adding one member means sending the existing emails back plus the new one.

application_list_users

ChatGPT
List or search an application's end users (people who log in to the published app, not builders/collaborators). Omit query to list users — first 10 by default. Provide query to filter by email or name: a case-insensitive substring matched against both fields. limit (1-100) and page (0-based) paginate; the response carries total and hasMore. Each user has id, email, name, status (NOT_INVITED, INVITED, PENDING_VERIFICATION, PENDING_SETUP, ACTIVATED or DEACTIVATED), active (false only when DEACTIVATED), created, lastSeen (null when they never signed in), and userGroups: the app's custom user groups the user belongs to, as {id, name}. Predefined groups like "All users" never appear there — use application_list_user_groups for full group details.

application_navigation_create

ChatGPT
Add a navigation (menu) to an application, alongside any it already has. A page shows one navigation, so different entries for different users on the same page come from item visibility (application_navigation_set_items), not from separate navigations. pageIds are the pages that should show it; each of them stops showing the navigation it had, since a page shows one. Without pageIds the new navigation is on no page yet - except an app's first navigation, which goes on every page. Either way it becomes the navigation blank pages added from now on get. Use application_page_set_navigation to put it on more pages later. primary, secondary, buttons and userMenu seed its item lists, as items without ids in the shape application_navigation_set_items takes; the menu starts empty without them. title names it in Softr Studio's navigation picker; omitted, it is "Navigation <n>". desktopLayout (top | side | top_and_side) and mobileLayout (top | bottom | top_and_bottom) are optional. Only apps built with Softr's current page builder have this navigation; a legacy app is refused with 400. A refused call changes nothing.

application_navigation_delete

ChatGPT
Delete a navigation with all its items. This removes it from every page showing it, which are left with no navigation, and cannot be undone. Confirm with the user before calling this unless they asked for it in as many words. To move pages to another navigation instead, use application_page_set_navigation; to drop some entries, use application_navigation_set_items.

application_navigation_get

ChatGPT
Get one navigation: its title, desktop and mobile layout, the pages showing it, the items of the menu's two slots (primary and secondary, as trees), its action buttons, its user (avatar) menu, and its display settings. Each item has an id, a type and a title. A LINK has an action: OPEN_PAGE with the pageId it opens, OPEN_URL with the url, or SIGN_OUT (Softr-managed; it cannot be removed). A link also reports openIn (SELF, TAB or MODAL, with modalSize and modalType) and, when set, its subtitle. A CATEGORY is a sub-menu holding children (links or further categories), with its subMenuStyle and showIcons. Each item also carries its visibility (user groups and devices). A page link with a "destination" instead of a pageId points at a path no page has any more - re-point it with application_navigation_set_items. buttons are the action buttons (e.g. "Sign up") shown next to the menu. userMenu is the menu logged-in users open from their avatar: whether it is enabled, its items, and signOut, its fixed last entry. Both hold links only. application_navigation_set_items edits all of these lists. settings lists every display option this navigation has, each as {"value": ..., "options": [...]} - options is present when the value is a choice. Change them with application_navigation_update_settings. Where the slots show depends on the layout. On desktop, "top" shows both slots in the top bar and "side" both in the sidebar; only "top_and_side" splits them, primary in the top bar and secondary in the sidebar. On mobile, "top" puts both in the top bar's menu and "bottom" both in a bottom tab bar, which shows 4-5 items and the rest under "More"; "top_and_bottom" puts primary in the top bar's menu and secondary in the bottom bar. hasSecondarySlot false means items cannot be put in the secondary slot. version identifies this state of the navigation; application_navigation_set_items needs it.

application_navigation_list

ChatGPT
List an application's navigations: the menus (top bar, sidebar, mobile bars) its pages show. An app can have several, and each page shows at most one of them, or none. Which entries of a navigation a user sees is set per item, with application_navigation_set_items. Returns, per navigation, its id, title, desktop and mobile layout, and the ids of the pages showing it. An empty list means the app has no navigation; application_navigation_create adds one. Call this first: every other navigation tool takes a navigationId from here. To find which menu a page shows, look for the page's id in pageIds; a page in no list shows no navigation.

application_navigation_rename

ChatGPT
Rename a navigation. The title is the name builders see in Softr Studio's navigation picker; app users never see it. Replaces the current title.

application_navigation_set_items

ChatGPT
Set a navigation's items: the menu's two slots, its action buttons and its user menu. Send the lists as they should be afterwards. Each list sent REPLACES that list: items are placed in the order given, an item listed with its id is moved there and keeps everything not given, an item without an id is created, and every item no longer listed in any list sent is REMOVED, a category with everything in it. A list left out is not touched. Read the navigation with application_navigation_get first and pass its version as expectedVersion; if the navigation changed since, the call is refused with 409 - read it again and resend. Lists: primary and secondary are the menu's slots and hold links and categories; buttons (action buttons, e.g. "Sign up") and userMenu (the avatar menu of logged-in users) hold links only. An item can move between lists sent in the same call. Sign-out links and items marked deletable: false are kept even when left out, at the end of their list; one inside a category cannot be dropped with it. The user menu's signOut entry is fixed and never listed. Each item is an object. An existing one needs only its id, plus any field to change: {"id": "<item id>", "title": "Orders"} A new one has no id: {"type": "LINK", "action": "OPEN_PAGE", "pageId": "<page id>", "title": "Orders", "icon": "receipt"} {"type": "LINK", "action": "OPEN_URL", "url": "https://example.com", "title": "Help", "icon": "help-circle"} {"type": "CATEGORY", "title": "Admin", "icon": "settings-01", "children": [<items>]} Fields, all optional for an existing item: "title", "icon" icon from application_list_icons; other names become link-01 (folder for a category) "pageId" | "url" re-point an OPEN_PAGE / OPEN_URL link (pageId from application_page_list; the sign-up, login and password pages only while the app's login and sign-up settings use them, never the onboarding page; url http(s), mailto, tel or sms, a domain, or a path starting / or #) "openIn": "SELF" | "TAB" | "MODAL" links: same tab, new tab or a modal "modalSize": "SM" | "MD" | "LG" | "XL", "modalType": "POPUP" | "SLIDING" links opening in a modal "subtitle": "..." links; "" switches it off. Shown only inside a MEGA_MENU category with the desktop "top" layout "subMenuStyle": "SIMPLE_DROPDOWN" | "TABS" | "MEGA_MENU" categories; applies to top-level categories with the desktop "top" layout "showIcons": true | false categories: whether their children show icons (desktop) "children": [<items>] categories: their items, replaced the same way; left out, the category keeps its children as they are "visibility": {"predefinedUserGroup": "ALL_USERS" | "LOGGED_IN_USERS" | "NON_LOGGED_IN_USERS", "customUserGroupIds": ["<group id>"], "devices": ["laptop", "mobile"]} An item's type and action cannot change: to turn a page link into a URL link, or a link into a category, leave the item out and add the replacement without an id. Categories nest at most 3 levels deep (top level is 1); links can go one level deeper. Visibility decides which entries each user sees, so one navigation can serve different users. Only the visibility fields given change. customUserGroupIds come from application_list_user_groups and apply only when predefinedUserGroup is (or is set in the same item to) LOGGED_IN_USERS; [] clears them. A predefinedUserGroup outside the item's enabledPredefinedUserGroups is refused. devices takes laptop and/or mobile, and tablets follow laptop. Hiding a category hides everything in it, and a category whose children are all hidden disappears. A new page link starts out visible to the same user groups as its page (a user menu link to logged-in users), and re-pointing a link resets that. This only hides menu entries: who may open a page is set by the page's own permissions (see application_page_get_permissions). Returns the whole navigation afterwards and the ids of the items created. Any invalid item fails the whole call and changes nothing; the error says what to fix.

application_navigation_set_layout

ChatGPT
Set where a navigation shows on the pages using it. Replaces the current layout for the devices given. desktopLayout: "top" (both slots in a top bar), "side" (both slots in a sidebar) or "top_and_side" (primary slot in the top bar, secondary in the sidebar). mobileLayout: "top" (both slots in the top bar's menu), "bottom" (both in a bottom tab bar showing 4-5 items, the rest under "More") or "top_and_bottom" (primary in the top bar's menu, secondary in the bottom bar). Send one or both.

application_navigation_update_settings

ChatGPT
Change a navigation's display settings. Each setting given replaces its current value; the rest are kept. application_navigation_get lists the settings this navigation has, with their current values and, for a choice, the allowed ones; send plain values here: {"sectionTitles": {"primary": "Main", "secondary": "More"}, "userMenu": {"enabled": true}, "logo": {"desktop": {"size": "1:1"}, "mobile": {"size": "1:2", "position": "CENTER_X"}}, "links": {"desktop": {"showIcons": true, "hierarchyTreeLines": false, "position": "START_X"}, "mobile": {"labels": true, "showIcons": true}}, "buttons": {"desktop": {"position": "END_Y", "showIcons": false}, "mobile": {"showIcons": false}}, "notifications": {"desktop": {"variant": "STANDALONE_ICON", "order": "FIRST"}}, "styles": {"desktop": {"topVariant": "accent", "size": "M", "roundness": null}, "mobile": {...}}} - sectionTitles name the menu's two slots in Softr Studio. - userMenu.enabled turns the avatar menu for logged-in users on or off. - logo sets the logo's variant and, on mobile, its position; the logo image itself is the app's logo. size is what Softr Studio calls the Variant: "1:2" is Horizontal, "1:1" is Square. position is "START_X" (left) or "CENTER_X" (centred). - links and buttons set how menu links and action buttons display. - notifications sets where the in-app notification inbox shows (as a primary or secondary menu link, in the user menu, or as a standalone icon) and, for a menu link, whether it comes first or last. It shows only when the user menu is enabled and in-app notifications are turned on for the app. Do not set mobile to STANDALONE_ICON while mobileLayout is "bottom": the bottom bar has no place for it, so the inbox would not show on mobile at all (Softr Studio does not offer it there). - styles set the bars' color variant, size and roundness per device; null makes one follow the app theme. A setting this navigation does not have, or a value outside its options, is refused, and nothing changes. Returns the whole navigation afterwards.

application_open

ChatGPT
Start a code application's workspace if it is not running, and wait (up to about 90 seconds) until it is ready. Returns the live previewUrl, the app's workspaceId and every file you can read and write. When the state is still "starting", call it again. Call it once at the start of the work and whenever another tool says the workspace is not running. Code apps only: a classic app has no workspace. To change an app that exists, read application_read_guide with topic "change-app" first, unless you already read it in this conversation.

application_page_create

ChatGPT
Create a new, empty page in an application and return its id, path, name and type. Use this when the user wants a brand-new page (a pricing page, a dashboard, an about page), as opposed to editing one that already exists — call application_page_list first to see what the app already has. Both name and path are required, and BOTH must be unique within the application: a duplicate name or a duplicate path is rejected with an error naming the conflict. name is the label shown in Studio UI's page list; path is the URL segment visitors see. path is normalized to a leading slash, so "pricing" and "/pricing" are equivalent and a trailing slash is dropped. The path "/" is REJECTED: that is the application's home page, which exists from the moment the app is created and is never added afterwards. If the user wants different content on the home page, edit the existing home page (find it with application_page_list) instead of trying to create one. The paths "/assets", "/studio" and "/health" (and anything nested under them) are reserved by Softr and rejected too. The page is created EMPTY — no blocks — and inherits the app's default view permissions (logged-in users if the app has login enabled, otherwise everyone). Adding content is a separate step: use vibe_coding_block_create to put a block on the page afterwards. Page nesting/ordering is not controlled here; a new page lands at the top level. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new page until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

application_page_delete

ChatGPT
Permanently delete a page from an application. Use this when the user wants a page gone — "delete the /portfolio page", "remove the page you created by mistake" — as opposed to emptying it, which is vibe_coding_block_delete on its blocks, or hiding it from some visitors, which is application_page_set_permissions. Call application_page_list first to find the page's id. This cannot be undone through MCP: no tool brings the page or its blocks back. Confirm with the user before calling it unless they were already explicit that this page should be deleted. Navigation menu items that link to the page are not removed with it; check them with application_navigation_get afterwards. Some pages cannot be deleted, and the call fails saying so: the application's home page (path "/"; another page has to become the home page in Softr Studio first, and no MCP tool does that), and the application's own utility pages such as log-in or sign-up (a copy of one can be deleted). Relay that to the user rather than looking for a way around it. Pages nested under this one in Studio's page list are KEPT by default and move up one level into its place (keptSubpageIds). Pass deleteSubpages=true only when the user wants them deleted too (deletedSubpageIds). With deleteSubpages=true the call is also refused when any nested page is one that cannot be deleted; delete without it instead. Deleting does NOT publish the change: the page disappears from Studio at once, but the live app keeps serving it until the next publish. Close by telling the user a Studio tab they already have open still lists the page until it is reloaded. Then offer to show them the app without it with application_preview, or to make the removal live with application_publish.

application_page_get

ChatGPT
Get a single page with its blocks. Returns page metadata plus a light list of blocks (id, name, title, type, category, enabled, visibility / user-group gating). Heavy custom code (markup/style/script) is intentionally omitted. The blocks are listed in the page's own order, top to bottom, so a block's position is its place in this list. The list is flat but a page is not: a block nested inside a column or tab container is listed alongside the rest, and it is the container that decides where it actually appears.

application_page_get_block

ChatGPT
Get a single block on a page by its block ID. Returns the block's structural metadata and visibility / user-group gating. Heavy custom code (markup/style/script) is omitted.

application_page_get_permissions

ChatGPT
Get the permission gating for a single page: for each permission type (VIEW/EDIT/ADD/DELETE) the user groups allowed to perform it. Use application_list_user_groups to resolve custom user-group IDs.

application_page_list

ChatGPT
List all pages of an application: id, path, name, whether enabled, page type, and title. Use this to understand an app's page structure before drilling into a page with application_page_get.

application_page_set_navigation

ChatGPT
Choose which navigation a page shows. A page shows at most one, so this replaces the navigation it had; pass no navigationId to leave the page with no navigation. The onboarding page cannot show one.

application_page_set_permissions

ChatGPT
Set who can open a page — the page's "Who can view" setting in Softr Studio (its VIEW permission). Use this for "make this page public", "only logged-in users should see the dashboard", "restrict /admin to the Admins group", or "show this page only to visitors who aren't signed in". Call application_page_get_permissions first to read the current setting. This gates the whole page: a visitor it excludes cannot open the page, whatever the blocks on it allow. vibe_coding_block_set_visibility gates a single block on a page the visitor can already open, so it cannot open up a page that this setting restricts. Turning end-user login off with application_set_login does NOT change this setting. A page set to LOGGED_IN_USERS then cannot be opened by anyone, because no one can log in. Set it to ALL_USERS here when the user wants the app public. Both parameters are optional, and each one you OMIT is left as it is. predefinedUserGroup must be one of ALL_USERS, LOGGED_IN_USERS or NON_LOGGED_IN_USERS. customUserGroupIds narrows a page to specific groups of logged-in users and is ONLY valid with LOGGED_IN_USERS, either set in the same call or already on the page. Call application_list_user_groups to turn a group NAME into its ID; only groups of type CUSTOM can be used. The list replaces the page's current groups, so include the ones to keep, and an empty list removes the group restriction. Moving a page off LOGGED_IN_USERS removes its custom groups too. Only regular pages have this setting. The application's utility pages (log-in, sign-up and the like) are rejected. The change does NOT go live until the app is published. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new setting until it is reloaded. Then offer to make it live with application_publish.

application_preview

ChatGPT
Build a preview of an application as it stands in the builder RIGHT NOW — unpublished changes included — and return a link to it as previewUrl, along with the pagePath it opens on. This is the tool for "show me", "can I see it", "send me a link", "does it actually work?": anything where the user wants to look at a change before real visitors do. CRITICAL: previewUrl is a credential, not just a location. The token in it signs whoever opens the link in as the user who asked for the preview, and it stays valid for about 24 hours. Give it to that user only, never post it anywhere other people can read, and call application_preview again rather than re-sending an older link — each call also rebuilds the preview from the app's current state, so a fresh link is the only one that shows the latest changes. Pass pageId to open the preview directly on one page — do this whenever the change you just made lives on a specific page, so the user lands on it instead of having to navigate there. Use application_page_list to find the ID. Omit pageId to preview from the app's home page. A pageId that belongs to a different application is rejected rather than quietly falling back to the home page. This publishes NOTHING: the live app and its real visitors are completely untouched. When the user wants the changes actually live for end users, that is application_publish instead. It is also not a way to read an app's configuration — use application_get, application_page_list or application_page_get for that. Give the user the returned previewUrl verbatim as a link, and tell them it is theirs alone and stops working after about a day.

application_publish

ChatGPT
Publish an application: make its CURRENT builder state live for real end users at the app's own URL, returned as publishedUrl. Use this ONLY when the user explicitly asks to publish, ship, deploy, or "make it live". Publishing is the user's decision — never do it on your own initiative just because you finished a change, and confirm before calling it. This is an APP publish, not a workflow publish. workflow_publish is a different tool acting on a different resource; do not substitute one for the other. It publishes the WHOLE application, not just the page or block you touched: every unpublished change anywhere in the app goes live at once, including changes made earlier, made by someone else, or ones you have never seen. If you have reason to think the app holds other pending work, say so before publishing. To let the user LOOK at a change without exposing it to real visitors, use application_preview instead — it covers "show me", "can I see it", "send me a link". There is no unpublish tool and no rollback tool here: MCP cannot undo a publish. Rolling the live app back to its previous content means changing the app back (e.g. with vibe_coding_block_restore_version) and publishing again, with the just-published version live in between. The user can also take the app offline entirely in Studio, under the app's Settings -> General -> Unpublish Application; that removes the live app rather than restoring the previously published version. Treat this call as not undoable from here. Publishing can be refused — an unverified account email, or edit access the user doesn't have on this app — in which case nothing goes live and the error says why. Relay that reason rather than retrying. After it succeeds, give the user the returned publishedUrl as a link so they can open the live app.

application_publish_status

ChatGPT
Report an application's latest publish. - Code app (VIBE_CODING_APPLICATION): where the publish is, as Softr Studio shows it: QUEUED, BUILDING (the app builds on its workspace), DEPLOYING (the build goes to hosting), VERIFYING (hosting accepted it and the address does not serve it yet), LIVE with the liveUrl, or FAILED with the step that failed. After application_publish, call it every 15 seconds or so until LIVE or FAILED. IDLE means no publish is known. - Classic app (REGULAR_APPLICATION, FORM_APPLICATION): a publish finishes within application_publish, so this reports LIVE with when the app was last published (updatedAt), or IDLE when it never was. application_get has its domain and subdomain.

application_read_file

ChatGPT
Read one file of a code application. Returns its content and its hash. The workspace formats every file it saves, but an edit quoted from what you last wrote to a file still applies, so do not read a file back only because you wrote it.

application_read_guide

ChatGPT
Read the playbooks for building and changing Softr apps. There is one per kind of work, and none needs an applicationId: "new-app" (build a new app from a description: every call in order, with its arguments, and the code templates), "change-app" (change a code app that exists) and "classic-app" (change a classic app: its pages, navigation and blocks). "tool-calls" holds the rarer arguments they point to. Read each playbook once in a conversation, before the first app of its kind; do not read it again for another app of the same kind. The other topics belong to one code app and take its applicationId: its own workspace serves them, so they match the patterns and the SDK it runs. Among them the rest of a new app's build: "new-app-pages" (its pages, with the team), "new-app-code" (the code rules) and each subagent's topic. With no topic: the overview and an index of every topic. Topics include "design-rules" (this app's look), "data-model" (the generated docs of the app's tables, with the ids the code takes), the runtime's skills (for example "build-a-calendar") and the Softr SDK skills (for example "softr-sdk/file-uploads").

application_register_data_source

ChatGPT
Register a specific table or sheet, from within a workspace data source, on a vibe-coding application. Softr generates the registration's dataSourceId and returns it in the response's datasource.datasourceId — read it from there; it is the id the application's generated code must reference. Registering a table that is already registered returns the existing registration (with its name updated) instead of creating a duplicate. To re-point or rename an existing registration, use application_update_data_source. Only for vibe-coding applications — a regular application wires data per block with vibe_coding_block_connect_data_source instead. For a Softr table (SOFTR_TABLES) omit integrationId: the workspace's own Softr Tables source is resolved from the application, and databaseId/tableId/tableName are the ids database_list, database_list_tables, database_get_table or database_create_table already gave you. Every data source type Softr supports can be registered. For an external source resolve the IDs in this order: integration_list (integrationId + type), then integration_list_databases (databaseId), then — for SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP only — integration_list_schemas (schema), then integration_list_tables (tableId/tableName). Proxy-only integrations (Gmail, Slack, Jira, OpenAI, ...) cannot be registered here — they are called through Softr's proxy instead, see application_get_integration_proxy_target. Registration only makes the table reachable, and limits no rows. Who may run each query and mutation is declared in the generated code, and the application's data restrictions apply on top.

application_remove_data_source

ChatGPT
Remove a registration from a vibe-coding application's registry, by the dataSourceId application_list_data_sources reports. Undoes application_register_data_source. A proxied integration (capability PROXY) has no registration to remove. It also removes the data restrictions granted against that table — unless another registration still points at the same table. The workspace integration itself stays connected. Does not change any generated code: code still referencing this dataSourceId will fail at runtime until it is updated (re-registering yields a new generated id).

application_remove_user

ChatGPT
Remove an end-user from an application, identified by their email. Returns a confirmation with the applicationId and email removed. This permanently removes the user from the app. Fails if no user with that email exists in the app. Use application_list first to find valid application IDs.

application_remove_user_connection

ChatGPT
Disconnect the table that authenticates an application's end users, so the app stops syncing with it. This detaches the table; it does not delete anything. Returns what was removed as source — the data source, database and table — so you can name it back to the user. After this call nothing else can, because application_get_user_connection reports empty from then on. What actually happens, which is worth telling the user before and after: - New and updated rows in that table STOP becoming app users. - Existing app users REMAIN and can still sign in; their records are untouched, they are just no longer synced from the table. - Condition-based user groups can no longer be authored or re-checked, because there are no field IDs to write them against. Existing ones keep their now-unresolvable field references. - The table itself is NOT deleted. This only disconnects it from the app. Recoverable, unlike deleting a user group: application_create_user_connection with the same table restores the connection. Do NOT promise the users come back with it — that needs a sync, and a sync only runs when two-way user sync is on for the app, which someone may have paused. Say the connection is restorable, and check userSyncStarted on the reconnect before telling anyone the users returned. Idempotent — an app with no users table returns disconnected: false rather than failing, so a false result means there was nothing to disconnect, not that the call went wrong. WARNING: confirm with the user before calling this. It is not something to do on your own initiative while fixing something else, and the Studio UI puts it behind a confirmation for the same reason. To point the app at a DIFFERENT table, use application_create_user_connection with replaceExisting rather than disconnecting first: it validates the new table before it touches the old one, so if the new table turns out to be wrong the app keeps the one it has instead of ending up with none.

application_screenshot

ChatGPT
Take a screenshot of one page of a code application's live preview and see it, rendered by a real browser next to the dev server. Signed out unless you pass asUserEmail, an app user's email (application_add_user adds one): the page then renders as that user sees it, their user group and data restrictions included. Use it once application_check is clean, on every page you built, as each kind of user who can open it: a page can type-check and still render empty, broken or wrong. The screenshot is a real visit: the page's loaders run as that user, so whatever the page does on load, such as creating a missing record for the user, it does here too. viewport is "desktop" (1440x900, the default), "tablet" (820x1180) or "mobile" (390x844). fullPage captures the whole scroll height instead of the viewport.

application_set_data_restriction

ChatGPT
Create a data restriction, or replace one by passing its dataRestrictionId. A restriction binds a set of user groups to ONE table and says, per operation, what they may do with its records and fields. REPLACES, it does not merge: userGroupIds, the table and rules each fully replace what the restriction held. To add a rule to an existing restriction, read it with application_list_data_restrictions and send its existing rules back alongside the new one. Operations you send no rule for are unrestricted. Each entry in rules is an object: {"operation": "VIEW", // VIEW | EDIT | DELETE | ADD, at most one rule per operation "effect": "RESTRICT", // RESTRICT (they can't) | ALLOW_ONLY (they can, nothing else) "records": "MATCHING", // ALL | MATCHING "condition": {"logicalOperator": "AND", "expressions": [{"subject": {"field": "<field reference>", "type": "TEXT"}, "operator": "IS", "value": ["{USER:::EMAIL}"]}]}, "fields": ["<field reference>"]} condition follows application_create_user_group's grammar - its operators, value as a list of strings, subject.type and the date tokens - except that subject names a field of THIS table, never "USER:...". So subject.type (TEXT, ARRAY, NUMERIC, DATE or BOOLEAN) comes from that field's type in integration_list_table_fields, mapped as application_get_user_connection describes. On a vibe-coded app a rule may carry "conditionV2" in place of "condition", a tree that can nest groups. "The owner is the signed-in user AND (Salary is empty OR Salary is over 100000)": {"operation": "VIEW", "effect": "ALLOW_ONLY", "records": "MATCHING", "conditionV2": {"operator": "AND", "conditions": [ {"operator": "IS", "leftSide": "<Owner field reference>", "rightSide": "{USER:::EMAIL}"}, {"operator": "OR", "conditions": [ {"operator": "IS_EMPTY", "leftSide": "<Salary field reference>"}, {"operator": "GREATER_THAN", "leftSide": "<Salary field reference>", "rightSide": 100000}]}]}} A group is {"operator": "AND" | "OR", "conditions": [...]}. Every other node is a leaf, whose leftSide is a field reference of this table, as condition's subject.field is. A leaf carries no field type. The leaf operators, by what they take: - rightSide, one value: IS, IS_NOT, GREATER_THAN, LESS_THAN, GREATER_THAN_OR_EQUALS, LESS_THAN_OR_EQUALS, CONTAINS, DOES_NOT_CONTAIN, STARTS_WITH, DOES_NOT_START_WITH, ENDS_WITH, DOES_NOT_END_WITH - rightSide, a list: IS_ONE_OF, IS_NOT_ONE_OF, HAS_ANY_OF, HAS_ALL_OF, HAS_NONE_OF - nothing: IS_EMPTY, IS_NOT_EMPTY - lowerBound and upperBound: IS_BETWEEN, IS_NOT_BETWEEN - lowerBound alone, a RELATIVE_DATE token: IS_WITHIN, IS_NOT_WITHIN Nothing else is accepted: check an operator against this list rather than relying on the refusal. The flat and tree shapes spell some operators differently (GT vs GREATER_THAN), so never copy one between them. A tree's date tokens are stored as sent, unchecked; the flat condition validates them. So send a date rule that needs no nested group as the flat condition, even on a vibe-coded app. A flat condition sent for a vibe-coded app is stored converted to conditionV2, so either works there; reach for conditionV2 only when the rule needs a group inside a group, or when sending back a rule that was read with one. Other apps take condition only and refuse conditionV2. Shape rules, each refused with the reason: - records MATCHING needs a condition or conditionV2, never both; records ALL must not carry either - every conditionV2 leaf needs an operator, a leftSide and, unless IS_EMPTY or IS_NOT_EMPTY, a value - an ADD rule must cover ALL records - ADD and DELETE rules take no fields - ALLOW_ONLY over ALL records with no fields restricts nothing - fields is only supported on vibe-coded applications A rule with fields never removes a record: the condition only picks the records it applies to. RESTRICT hides those fields on the matching records; ALLOW_ONLY shows ONLY those fields on them, and other records keep all theirs; on EDIT the fields stay readable but cannot be changed. So on a vibe-coded app "contractors see only their own records, and not the Salary on them" is two restrict…

application_set_domain

ChatGPT
Connect, replace or disconnect an application's custom domain. Pass domain as a bare hostname like "app.example.com" (no scheme, path or port); omit domain to disconnect and go back to the app's subdomain. An apex domain like "example.com" is stored as "www.example.com" — report the returned value. Fails for Softr-zone domains, domains connected to another app, and on plans without custom domains. IMPORTANT: connecting here does NOT make the domain serve the app by itself. The user must point the domain's DNS at Softr (done in their DNS provider and Softr Studio, not through this tool) and the app must be republished (application_publish). Report the domain as pending DNS setup and republish, not as live. Use application_list to find application IDs.

application_set_login

ChatGPT
Enable or disable end-user login for an application. Pass enabled=true to turn login on, or enabled=false to turn it off. Returns the applicationId and the resulting loginEnabled value. Disabling login locks EVERY existing end user out of the live app for as long as it stays off, which is why this tool is marked destructive. It is reversible — call this tool again with enabled=true to turn login back on — but confirm a disable with the user before calling it. Only applies to apps that support login; studio-api rejects apps without login settings. Use application_list to find application IDs. IMPORTANT: login CANNOT be disabled while the application still has users — the call fails with a conflict error saying so. Do not report login as disabled unless this call succeeded; relay the error instead. To proceed, remove all application users first (application_remove_user), then disable login.

application_set_name

ChatGPT
Rename an application. Returns the applicationId, the final name and the previousName. The name is trimmed, must be 1-64 characters, must not contain links, HTML or script, and must be unique within the workspace. When another app already uses the name, the app gets the first free " (n)" suffix, for example "Bug Tracker (2)", and the call succeeds. Read the final name from the response and use that name when you tell the user; do not retry with a name of your own. Do not report the app as renamed unless this call succeeded; relay the error instead. The new name REPLACES the old one, which is why this tool is marked destructive; the response returns previousName, so the old value is not lost to the caller. Renaming changes only the display name: the subdomain, custom domain and app URL stay the same, and the new name is live at once without a publish. Use application_list to find application IDs.

application_set_subdomain

ChatGPT
Change the subdomain an application is served on (my-app.softr.app). The new label REPLACES the old one, so every link to the previous address stops working once the app is republished. Pass just the label ("my-app") — the app's zone (.softr.app, or the app's existing zone) is kept and cannot be changed; a full host is accepted only with that same zone. Labels are lowercased and must be 1-63 characters of a-z, 0-9 or '-'. Fails if another application already uses the subdomain. Returns the full persisted subdomain and the previous one. IMPORTANT: the live app keeps serving on the PREVIOUS host until the app is republished (application_publish) — report the returned subdomain as pending until then, not as live. Use application_list to find application IDs.

application_set_user_activation

ChatGPT
Activate or deactivate an application end-user, identified by their email. Pass active=true to activate, active=false to deactivate. Deactivating locks that person out of the live app until someone reactivates them, which is why this tool is marked destructive; confirm a deactivation with the user before calling it. They are NOT deleted — their account and data stay, and reactivating restores their previous status. Use application_remove_user only when the user should be permanently removed. Setting a user to the state they are already in succeeds without changing anything. The response reports the persisted state: active plus the exact status (e.g. ACTIVATED, DEACTIVATED, NOT_INVITED) — report that, not the requested value. In the response, active means only "not deactivated", NOT "able to sign in": a user with status NOT_INVITED, INVITED, or PENDING_VERIFICATION reports active=true but has never signed in — never tell the user such a user can sign in; go by status. Fails if no user with that email exists in the app. Use application_list to find application IDs.

application_update_data_source

ChatGPT
Re-point an existing application datasource registration at another table, or rename it, keeping the dataSourceId the application's generated code already references. What you pass REPLACES the registration's current table coordinates, which is why this tool is marked destructive: code already written against the old table keeps the same dataSourceId but now reads a different one. Update-only: the dataSourceId must be an existing registration's id, from application_list_data_sources or an application_register_data_source response — an unknown id fails rather than creating a registration (new ones are created by application_register_data_source, which generates the id). Takes the same table coordinates as registration.

application_update_push_notification_settings

ChatGPT
Turn push notifications on or off for an application's desktop and mobile visitors, and set its permission prompt. These are the settings Studio's Users -> Notifications edits. Every field except applicationId is optional; an omitted one keeps its current value. Turning a device type on when no prompt is set fills a default prompt: the title "Turn on push notifications", the message "Get notified about important updates", an "Enable" button, and asking again 30 days after a visitor skips it. skipDays only takes "7", "14", "30" or "never"; when the user asks for another number of days, offer the nearest of those. Turning a device type on or changing the prompt fails with 402 when the workspace's plan does not include push notifications; tell the user that instead of retrying. Turning push off is never refused, but it stops every visitor on that device type from getting notifications, so confirm that with the user first. The prompt differs by kind of app (application_get's applicationType): a classic app (REGULAR_APPLICATION, FORM_APPLICATION) shows Softr's own prompt with the text set here, while a code app (VIBE_CODING_APPLICATION) shows none from these settings alone: it needs one in its own code. Either way, notifications are sent by a workflow, never by the app. Use application_list to find application IDs.

application_update_pwa_settings

ChatGPT
Turn an application's installable-app (PWA) support on or off and set how it looks once installed on a phone or desktop: name, shortName (under the home-screen icon) and themeColor. These are the same settings as Studio's Settings -> Mobile app, so the builder sees what you set there. Every field except applicationId is optional; an omitted one keeps its current value. Pass enabled=true to turn PWA on. Turning PWA on fills what you did not pass: the app's name, a shortName cut from it and a white theme colour. You cannot set an icon here. When icon512 in the response is empty, the app is NOT installable yet: tell the user to upload a square 512x512 PNG icon in Settings -> Mobile app. Fails with 402 when the workspace's plan does not include PWA (Business plan or higher); tell the user that instead of retrying. Turning PWA off is never refused. enabled=false stops everyone from installing the app, so confirm that with the user first. Settings alone do not show an install button: the app needs one in its own code. Apps people already installed keep their old name and icon. Use application_list to find application IDs.

application_update_user_group

ChatGPT
Update a custom end-user user group: rename it, replace its members, or replace its condition. Returns the updated group: id, name, type, userEmails, condition and order. Every field except applicationId and userGroupId is optional, and omitting one leaves that part of the group untouched. Supplying userEmails converts the group to manual and DISCARDS its condition; supplying condition converts it to condition-based and DISCARDS its member list. Supplying both fails with a 400. Call application_list_user_groups first to see the group's current kind, and pass at least one field to change - an update with nothing to change fails. userEmails and condition REPLACE what the group had; they do not merge. To add one person to a manual group, read its current userEmails from application_list_user_groups and send the full list back with the addition. Condition rules are the same as for application_create_user_group: call application_get_user_connection for the real fields and reference them and their choices by its fieldReferenceKey, value is always a list of strings even for one entry and even when subject.type is TEXT, and IS_NOT/NOT_EQUAL on an ARRAY field is rejected because it matches no users - use HAS_NONE_OF. The operator's value count is enforced too ([] for IS_EMPTY/IS_NOT_EMPTY, exactly two for BETWEEN, at least one otherwise), and a DATE subject takes a structured token such as "PREDEFINED:TODAY" or "FIXED_DATE:DAYS_AGO:<n>" rather than prose. A new name must be free within the application, case-insensitively, so check application_list_user_groups before renaming rather than spending a call on a clash. Fails with a 404 if the group is not in this application, and a 409 if it is a predefined group (Logged in users, Visitors, Everyone) or the new name is already taken. Unlike creating, updating is not blocked when the workspace is over its plan allowance. Relay whichever of those it fails with as it is; none of them is fixed by retrying the same call.

application_write_files

ChatGPT
Create, overwrite or delete several files of a code application in one call. All of them land together as ONE checkpoint the user can restore in Softr Studio, so put a whole feature in one call. Each entry is {"path": ..., "content": ...} to create or overwrite a file with its full new contents, or {"path": ..., "delete": true} to delete one. Up to 100 files. Optional "baseHash" on an entry refuses the call when that file changed since you read it. The workspace formats what you write. Writable paths: src/*, app/.json, softr.json, components.json, package.json, tsconfig.json, vite.config.ts, tsr.config.json. Never write src/routeTree.gen.ts or softr-env.d.ts: both are generated. Run application_check afterwards.

database_aggregate_records

ChatGPT
Aggregate table data with grouping and metrics (SUM, AVG, COUNT, MIN, MAX, DISTINCT). Returns pre-aggregated rows, so the caller does not read every record and total them itself. metrics (required): [{"field": "fieldId", "aggregation": "SUM"|"AVG"|"MIN"|"MAX"|"COUNT"|"DISTINCT"}] For COUNT aggregation, the field value is ignored (counts all rows). groupByFields (optional, max 2): [{"field": "fieldId", "options": {"timeInterval": "DAY"|"WEEK"|"MONTH"|"QUARTER"|"YEAR"|"HOUR_OF_DAY"|"DAY_OF_WEEK"|"MONTH_OF_YEAR"|"QUARTER_OF_YEAR", "displayFormat": "YYYY-MM-DD"}}] options is only needed for date/datetime fields. If omitted, returns a single row with the metric totals. filter (optional): Same format as database_search_records filter. Call database_get_field_reference for the full filter operator reference. sortingOptions (optional): [{"sortingField": "fieldId", "sortType": "ASC"|"DESC"}] — only for grouped queries. Field keys in groupByFields, metrics, and sortingOptions must be field IDs, taken from database_get_table or database_list_fields if you do not already have them.

database_attach_file_from_url

ChatGPT
Add a file to a record's ATTACHMENT field from a URL. The files already in the field stay. Use it when the user gives a link to a file. The server downloads the file and stores its own copy, so the attachment keeps working when the URL stops working. The URL must return the file itself. A share page (for example a Google Drive or Dropbox page) returns a web page, not the file. Use the direct download link in that case. For a file on the user's computer, use database_create_attachment_upload_link. Returns the updated record. Field keys in the response are field IDs.

database_create

ChatGPT
Create a new database in the specified workspace. Requires write permission to the workspace. Returns the created database with its generated ID. On the vibe coding application endpoints the new database is empty. Create its tables with database_create_table. On every other endpoint the new database already contains one empty starter table named "Table 1", holding Name, Description and Status fields - the same table the Softr builder creates. Reshape that table with database_update_table, database_create_field and database_update_field instead of calling database_create_table, which would leave the starter table behind as a second, empty one. A database with that starter table is not empty, so database_delete refuses it without force=true. Pass timezone and locale only when you know them, for example because the user named their city, country or language. Do not guess them, and do not pass UTC as a stand-in for "unknown": without a timezone each viewer sees their own browser timezone, while "UTC" would fix every viewer to UTC. Without a locale dates use English formats. They work as in database_update.

database_create_field

ChatGPT
Add a new field to a table. Field types: SINGLE_LINE_TEXT, LONG_TEXT, CHECKBOX, NUMBER, PERCENT, CURRENCY, RATING, DATETIME, SELECT, EMAIL, PHONE, URL, USER, ATTACHMENT, LINKED_RECORD, DURATION. Computed (read-only) field types: FORMULA, LOOKUP, ROLLUP. Their values are derived automatically. COUNT is not a supported field type; a request with type COUNT is rejected. System (read-only) field types that take no options: CREATED_AT, UPDATED_AT, CREATED_BY, UPDATED_BY, AUTONUMBER, RECORD_ID. Type-specific 'options': - SELECT: 'choices' as an array of string choices. 'allowMultipleEntries': true makes it a multi-select whose value is an array of choices; omit it for a single choice. - LINKED_RECORD: 'linkedTableId' (the table to link to); the inverse link field on that table is created automatically. Optionally set 'allowMultipleEntries' (boolean) to allow linking multiple records. - FORMULA: 'formula' (string expression; referenced fields and return type are resolved automatically). - LOOKUP: 'linkedRecordFieldId' (a LINKED_RECORD field in this table) and 'lookupFieldId' (a field id in the linked table). - ROLLUP: 'linkedRecordFieldId', 'rollupFieldId' (field id in the linked table) and 'function' (SUM, MIN, MAX, COUNT, AVERAGE, ARRAYCOMPACT, ARRAYJOIN, ARRAYUNIQUE, ARRAYFLATTEN, CONCATENATE, COUNTALL, COUNTA, OR, AND). To count linked records, use function COUNTALL and set 'rollupFieldId' to the linked table's primary field. Call database_get_field_reference first for the authoritative reference of field types, their options, and value examples.

database_create_record

ChatGPT
Create a new record with specified field values. Fields is an object mapping field IDs to values. Take the IDs from database_get_table or database_list_fields if you do not already have them. For DATETIME fields, use ISO format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' For SELECT fields, use the option value as a string. For CHECKBOX, use true/false. createdAt is optional: an ISO 8601 UTC time, not in the future, for example 2026-01-31T09:00:00Z. It sets the record's creation time, for example for demo data from past weeks. Without it, the creation time is now. Returns the created record with its generated ID. Field keys in the response are field IDs — resolve them with the same field list.

database_create_records

ChatGPT
Batch create multiple records. Maximum 100 records per call. Each record should have a 'fields' object mapping field IDs to values. Take the IDs from database_get_table or database_list_fields if you do not already have them. A record may also have a 'createdAt' next to 'fields': an ISO 8601 UTC time, not in the future, for example 2026-01-31T09:00:00Z. It sets the record's creation time, for example to spread demo data over past weeks. Without it, the creation time is now. Returns the list of created records with their generated IDs. Field keys in the response are field IDs — resolve them with the same field list.

database_create_table

ChatGPT
Create a new table in a database. Field types available: SINGLE_LINE_TEXT, LONG_TEXT, CHECKBOX, NUMBER, PERCENT, CURRENCY, RATING, DATETIME, SELECT, EMAIL, PHONE, URL, USER, ATTACHMENT, LINKED_RECORD, DURATION. Computed (read-only) field types: FORMULA, LOOKUP, ROLLUP (values derived automatically). COUNT is not a supported field type. To count linked records, use a ROLLUP field with function COUNTALL. System (read-only) field types that take no options: CREATED_AT, UPDATED_AT, CREATED_BY, UPDATED_BY, AUTONUMBER, RECORD_ID. For SELECT type, include 'options' with 'choices' as an array of available choices. Add 'allowMultipleEntries': true in the same 'options' for a multi-select ("select all that apply"): its value is then an array of choices. Without it a SELECT holds exactly one choice. For LINKED_RECORD type, include 'options' with 'linkedTableId' referencing an existing table. USER holds a Softr workspace collaborator, not an end user of the app. Do not use it unless the user explicitly asks for it. For "who owns this record" use a LINKED_RECORD to the table that holds the people or users, with LOOKUP fields for the details a page shows, or alternatively an EMAIL field. ATTACHMENT holds one or more files; database_get_field_reference shows an example value. For computed fields, see the database_create_field tool for the required 'options' per type. Call database_get_field_reference first for the authoritative reference of field types, their options, and value examples.

database_create_view

ChatGPT
Create a saved view on a table, optionally configured in the same call: hide fields, sort, group, and filter. Every field is referenced by its FIELD ID, never its name — call database_get_table or database_list_fields first to resolve names (e.g. "Name", "Status") to ids, then pass the ids here. A config part you omit keeps the default: all fields visible, no sorting, no grouping, no filter. Formats: - hiddenFields: ["fieldId", ...] - sorting: [{ "fieldId": "fieldId", "direction": "ASC"|"DESC" }, ...] - grouping: [{ "fieldId": "fieldId", "direction": "ASC"|"DESC" }, ...] (max 3 levels, distinct fields) (sorting and grouping also accept "sortingField"/"sortType" as synonyms for "fieldId"/"direction") - filter: same format as database_search_records — { "condition": { "operator": "AND"|"OR", "conditions": [...] } } with Binary/Unary/Ternary conditions whose leftSide is a field id. Call database_get_field_reference for the operators each field type supports — the filter is SAVED on the view, so a wrong operator would misfilter every later read. An unknown field id anywhere in the config fails the whole call with a 400 — nothing is created. The name is required and not unique: creating the same name twice makes two views. Returns the new view's id and name; use database_list_views to see all views.

database_delete

ChatGPT
Delete a database permanently, together with every table, field and record it contains. Deletion fails if the database still has tables; set force=true to delete it anyway. This is also the only way to remove a database's last table, which database_delete_table rejects. WARNING: This action cannot be undone. Confirm with the user before calling it.

database_delete_field

ChatGPT
Delete a field from a table, together with its value in every record of that table. A table's primary field cannot be deleted. Softr removes the field from any view's filters and sorts and marks formulas that referenced it invalid. It does NOT clean up two things, so tell the user about them rather than assuming they are handled: deleting a LINKED_RECORD field leaves the inverse link field on the other table in place, which has to be deleted separately if the relationship is going away; and lookups and rollups reading through the deleted field are left as they are. WARNING: This action cannot be undone. Confirm with the user before calling it.

database_delete_record

ChatGPT
Delete a single record from a table. Fails if no record with that ID exists in the table. WARNING: This action cannot be undone. Confirm with the user before calling it.

database_delete_records

ChatGPT
Delete several records from one table in a single call. At most 100 record IDs per call. IDs that no longer exist are skipped rather than failing the batch, and the returned message reports how many records were actually deleted. WARNING: This action cannot be undone. Confirm with the user before calling it.

database_delete_table

ChatGPT
Delete a table permanently, together with its fields, views and every record it holds. Deletion fails if the table still has records; set force=true to delete it anyway. Any LINKED_RECORD field in another table that points at this one loses its links. A database cannot be left without tables, so deleting its only table is rejected and force does not override that. Before deleting, check the database's tablesCount from database_get (or count database_list_tables): if this is the last table, do not call this tool. Tell the user the database cannot be left empty and ask whether they want the whole database gone — if they do, call database_delete with force=true instead, which removes the database and this table with it. WARNING: This action cannot be undone. Confirm with the user before calling it.

database_get

ChatGPT
Get details of a specific database by ID including name, description, workspace, table count, timestamps and localization: timezone, dateLocale and numberLocale. Use this to get full information about a database before working with its tables, and to see its current localization before you change it with database_update. timezone is the IANA timezone that every viewer sees dates and times in. dateLocale formats dates (for example 31.12.2026 for de-DE) and numberLocale sets the thousands and decimal separators (1.000,5 for de-DE) for every viewer. A null value means each viewer's own browser timezone or locale is used; a null dateLocale can also mean a custom date format that was set in the Softr builder.

database_get_field_reference

ChatGPT
Get Softr Tables' field-type and filter-operator reference: all field types with descriptions, available/required options and value examples, filter operators (binary, unary, ternary, composite), and the list of read-only field types. This is the reference for the whole product, not the schema of one table: it takes no table ID and returns the same content every time. To read the fields of a specific table, use database_get_table. Call this before database_create_table, database_create_field, or database_update_field, and when building filters for database_search_records or database_aggregate_records. Do not guess field types, options, or operators.

database_get_record

ChatGPT
Get a single record by ID with all field values, createdAt, and updatedAt. Returns null if the record is not found. Field keys in the response are field IDs, not human-readable labels. Map them with the field list from database_get_table or database_list_fields — one schema call per table is enough; skip it if you already have it.

database_get_table

ChatGPT
Get one table in a single call: id, name, description, defaultViewId, primaryFieldId, and every field definition (id, name, type, options, required, readonly) — the same field list database_list_fields returns. This is the one schema call you need for a table whose id you already know, whether you are going to read, query, aggregate or write its records. Do not follow it with database_list_fields, and do not call it again for the same table unless you changed its fields yourself (database_create_field, database_update_field) in between.

database_list

ChatGPT
List databases (tablespaces) accessible to the authenticated user, optionally only those of one workspace. Returns id, name, description, workspaceId, tablesCount, createdAt, updatedAt, timezone, dateLocale and numberLocale for each (database_get explains the last three). Use this to discover available databases before querying tables or records. Pass workspaceId whenever you know it (application_get returns the application's): the unfiltered list covers every workspace you can see and can be very large. When you already know part of the database's name, database_search narrows it further. This is Softr's own internal databases (SOFTR_TABLES) only. To browse a different kind of workspace data source (Airtable, Google Sheets, Notion) — or specifically to resolve IDs for vibe_coding_block_connect_data_source — use integration_list + integration_list_databases instead.

database_list_fields

ChatGPT
List all fields in a table with id, name, type, options, and configuration. Returns exactly the fields database_get_table inlines; use it when you want the fields without the table's metadata, and never in addition to database_get_table for the same table. One call per table is enough.

database_list_records

ChatGPT
List records from a table. Optionally filter by a saved view. Supports pagination with offset (default 0) and limit (default 20, max 200). A limit above 200 is silently clamped to 200 rather than rejected, so never assume a single call returned everything: page with offset until fewer than limit records come back. Returns records with all field values, id, createdAt, and updatedAt. Field keys in the response are field IDs, not human-readable labels. Map them with the field list from database_get_table or database_list_fields — one schema call per table is enough; skip it if you already have it.

database_list_tables

ChatGPT
List all tables in a database with id, name, description, recordsCount, createdAt, updatedAt. Use this to discover tables in a database before working with records. This is for a Softr Tables (SOFTR_TABLES) database only. For an Airtable/Google Sheets/Notion data source, or to specifically resolve IDs for vibe_coding_block_connect_data_source, use integration_list_tables instead.

database_list_views

ChatGPT
List all saved views for a table with id, name, and configuration. Views represent saved filters/sorts that can be used with database_list_records.

database_search_records

ChatGPT
Search records with filter conditions and sorting. Filter format: { "condition": { "operator": "AND"|"OR", "conditions": [...] } } Condition types: - Binary: { "operator": "IS"|"IS_NOT"|"CONTAINS"|"GREATER_THAN"|etc, "leftSide": "fieldId", "rightSide": "value" } - Unary: { "operator": "IS_EMPTY"|"IS_NOT_EMPTY", "leftSide": "fieldId" } - Ternary: { "operator": "IS_BETWEEN"|"IS_NOT_BETWEEN", "leftSide": "fieldId", "lowerBound": "value1", "upperBound": "value2" } leftSide is always a field ID (from database_get_table or database_list_fields), not a field name. Binary operators: IS, IS_NOT, GREATER_THAN, GREATER_THAN_OR_EQUALS, LESS_THAN, LESS_THAN_OR_EQUALS, CONTAINS, DOES_NOT_CONTAIN, STARTS_WITH, ENDS_WITH, IS_ONE_OF, IS_NOT_ONE_OF, HAS_ALL_OF, HAS_NONE_OF, HAS_ANY_OF Sorting format: [{ "fieldId": "fieldId", "direction": "ASC"|"DESC" }] ("sortingField"/"sortType" are accepted synonyms for "fieldId"/"direction") Call database_get_field_reference first for the full filter operator reference with descriptions and examples. Field keys in the response are field IDs, not human-readable labels. Map them with the field list from database_get_table or database_list_fields — one schema call per table is enough; skip it if you already have it.

database_set_primary_field

ChatGPT
Make a field the table's primary field. It replaces the current primary field, which stays in the table as an ordinary field. The primary field is the record's name: Softr shows it in record pickers and in the cells of other tables that link here, and a LINKED_RECORD write that passes a name instead of a record id is matched against it. Allowed types: SINGLE_LINE_TEXT, LONG_TEXT, EMAIL, PHONE, URL, NUMBER, DATETIME, CREATED_AT, FORMULA, AUTONUMBER, RECORD_ID. Any other type is rejected. Typical use: a record people cite by a key such as "BUG-12". database_create_table with the title first and an AUTONUMBER field "Number", then database_create_field adds a FORMULA "ID" with formula "BUG-" & {Number}, then this tool makes that formula primary. Returns the table with its new primaryFieldId.

database_update

ChatGPT
Update a database's name, description, timezone and/or locale. Only provided fields will be updated; each one REPLACES the stored value, which is not kept. timezone and locale change the database's localization, like the localization panel in the Softr builder. They decide how date, date-time and number fields show their values to every viewer of the database, and the timezone also decides where a day starts for date filters such as "today". Stored record values are not converted. Call database_get first to see the current timezone, dateLocale and numberLocale. A bad timezone or locale is rejected and then nothing is changed. A locale sets the date format as well as the number separators: it replaces a custom date format (such as DD-MM-YYYY) that was set in the Softr builder. When database_get shows a null dateLocale, ask the user before you pass a locale, unless they asked for the change. There is no way back to the viewers' browser settings: a blank timezone or locale is ignored, and a value such as "local" is rejected. Once set, a timezone or locale can only be replaced by another one. Only the date format can be switched back to the browser locale, by the user in the Softr builder's localization panel.

database_update_field

ChatGPT
Update a field's name, description or options. Only what you pass changes: a parameter you omit keeps its stored value, so renaming a field does not disturb its configuration. Each key inside 'options' is applied on top of the field's current configuration, and a key that the field type does not accept is rejected rather than ignored — so send the keys you want to change, not the whole option set. The value of a key REPLACES the stored one: pass 'choices' as the full list you want the field to end up with (existing choices keep their ids; a new one needs no id), and note that dropping a choice can orphan values already held in records. Multi-value fields are controlled by 'allowMultipleEntries' inside 'options' — true makes a SELECT a multi-select or a LINKED_RECORD hold several records, false makes it single-valued. Cannot change the field type, or rewire what the field points at (linked table, formula, lookup and rollup wiring): delete the field and create a new one for that. Call database_get_field_reference first for the available options per field type.

database_update_record

ChatGPT
Update specific fields of a record. Each field you pass REPLACES its stored value, and the previous value is not kept. Only provided fields are updated; other fields remain unchanged. Field keys in the request must be field IDs, taken from database_get_table or database_list_fields if you do not already have them. Returns the updated record. Field keys in the response are field IDs — resolve them with the same field list.

database_update_table

ChatGPT
Update a table's name and/or description. Only provided fields will be updated; each one REPLACES the stored value, which is not kept.

integration_get_sample_records

ChatGPT
Read a sample of REAL records from a table of an external data source (Airtable, Google Sheets, Notion, Supabase and every other type integration_list_tables can browse), so the values you build against are the ones the data actually uses. Call it after integration_list_table_fields and before writing any code, filter, user-group condition or status mapping that names a value of that table — never guess a status label, a role name, a date format or which sheet tab holds what when you can read them here. Values are case- and whitespace-sensitive at runtime: use them exactly as returned ("sold", not "Sold"). Returns: records — the first limit records (default 20, max 100): id plus a fields map keyed by the table's fieldReferenceKey (the field's id or its name, exactly as integration_list_table_fields reports). Long text is cut at 500 characters. valueSummary — one entry per field: the distinct values seen in the sample (first-seen order, at most 20, truncated when there were more), distinctCount, emptyCount, and complex for fields whose values are objects (attachments, linked records) — read those from records instead. This is the quickest way to learn a status/role/category column's real options when the field metadata has none (Google Sheets, SQL text columns). fields — reference/id/name/type for every field of the table, so you can pick fields for a narrower follow-up call. totalCount — the table's record count when the source reports it, else null. Everything is derived from the sample: a value that is not in it may still exist in the table. To learn more of a column's values, call again with fields set to that column and a higher limit. Reads go through the application being built: pass the vibe-coding application's id (the app must exist — create it first). Same id hierarchy and schema rule as integration_list_table_fields: resolve integration_list → integration_list_databases → (integration_list_schemas for SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE, CLICKUP) → integration_list_tables. For a Softr table (SOFTR_TABLES) use database_list_records / database_search_records instead. The first read of a table no Softr app has used before starts its sync; a large Airtable base or sheet may not finish within the call and you get a CONFLICT asking you to retry in ~10 seconds — do retry, once or twice, rather than falling back to guessing. The read is reused by the application once it connects the table, so it costs nothing extra.

integration_list

ChatGPT
List the integrations connected to a workspace: id, name, type and capabilities for each. Use this tool whichever of the two words the user says — it is the entry point for both. A data source is a KIND of integration, not another word for one. An integration that holds records is a data source (Softr's own SOFTR_TABLES, plus external ones like Airtable, Google Sheets, Notion or a SQL database); a proxy-only integration (Gmail, Slack, OpenAI, ...) is still an integration but has no records and nothing to browse inside it. capabilities is where that difference is reported for a vibe-coding application — read it rather than guess from the type, since one integration can carry both: DATA — it has tables: browse them with the integration_list_* tools and register the ones the app uses with application_register_data_source. PROXY — its own API is called through Softr's proxy: get the target with application_get_integration_proxy_target. The data source types — each one browsable with integration_list_databases/integration_list_tables and connectable to a block with vibe_coding_block_connect_data_source — are SOFTR_TABLES, AIRTABLE, GOOGLE_SHEET, MICROSOFT_EXCEL, NOTION, MONDAY, SMARTSUITE, CLICKUP, CODA, HUBSPOT, SALESFORCE, ZOHO_CRM, REST_API, GOOGLE_BIGQUERY, and the SQL vendors SUPABASE, POSTGRESQL, MYSQL, MARIADB, SQL_SERVER, SNOWFLAKE and XANO_SQL. Anything else this returns carries PROXY only. Some types have a third level between database and table, so browsing them means integration_list_databases, then integration_list_schemas, then integration_list_tables: SUPABASE, POSTGRESQL, SQL_SERVER and SNOWFLAKE (a SQL schema), GOOGLE_BIGQUERY (a dataset), SMARTSUITE (a solution) and CLICKUP (a space). Everything else goes straight from database to tables.

integration_list_databases

ChatGPT
List the top level of a workspace data source (see integration_list) — what that level is depends on the type: an Airtable base, a Google Sheets spreadsheet, an Excel workbook, a Notion database, a Coda doc, a Monday/SmartSuite/ClickUp workspace, a BigQuery project, a SQL database, or, for the flat sources (HUBSPOT, SALESFORCE, ZOHO_CRM, REST_API), the object/module/resource itself. Returns id and name for each. Use this before vibe_coding_block_connect_data_source to resolve a valid databaseId. For SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP the next step is integration_list_schemas, not integration_list_tables. A SQL connection usually has exactly one database, so expect a single entry for those. For the flat sources the database and the table are the same thing: integration_list_tables will return one entry echoing what you picked here. Pass both ids through anyway. Narrow-purpose: only id/name are returned, with no record/field/aggregation capability. If the data source is SOFTR_TABLES and you need more than that (searching/creating records, field schemas, aggregation), use database_list/database_list_tables/database_list_fields/database_search_records instead — this tool exists to resolve IDs for vibe_coding_block_connect_data_source and to cover the external sources those tools can't reach at all.

integration_list_schemas

ChatGPT
List the middle level of a data source whose hierarchy is database -> X -> table. Returns an id and a name for each: match the user's words against name, but pass `id` back as the schema argument of the later calls. For the SQL types the two are the same string, because a schema really is addressed by its name; for BigQuery, SmartSuite and ClickUp they are not — a ClickUp space, for example, may have a human-readable name while its id is an opaque numeric string. Only these types have the level: SUPABASE, POSTGRESQL, SQL_SERVER and SNOWFLAKE (where it is a SQL schema), GOOGLE_BIGQUERY (a dataset), SMARTSUITE (a solution) and CLICKUP (a space). Resolve identifiers in this order: integration_list (integrationId and type), integration_list_databases (databaseId), integration_list_schemas (schema), then integration_list_tables with that schema. Calling this for any other type fails with a message saying so — including MYSQL, MARIADB and XANO_SQL, which look like they should have schemas but conflate them with the database. Go straight from database to tables for those. For Supabase and Postgres, "public" is almost always the one the user means. Supabase's internal schemas (extensions, vault, pgbouncer, pgsodium, graphql, pg_catalog, ...) are filtered out, and its "auth" schema exposes only users, sso_domains, sso_providers and audit_log_entries.

integration_list_table_fields

ChatGPT
List field metadata (id, name, type, and type-specific options — select choices, linked table id, etc.) for a specific table within a workspace data source. Also returns primaryFieldId — the field that identifies a single record. Check it before writing any code that reads or modifies one record: a null primaryFieldId means none could be determined (for SQL sources, the table has no primary key — most often because it is a database view), so listing records works but useRecord() and every create/update/delete will fail at runtime even though the block compiles. Treat such a table as read-only and say so if the user asked for writes. Also returns fieldReferenceKey — "id" or "name" — the property you MUST use to reference this table's fields in query/filter code (q.select(), where conditions, ...). Getting this wrong compiles and saves fine but silently fails at runtime, so read it rather than guessing: it is "id" for SOFTR_TABLES, SMARTSUITE, CLICKUP, MONDAY, CODA, HUBSPOT, SALESFORCE and ZOHO_CRM, and "name" for every other type. For SQL sources the two are the same string anyway (a column's id is its name). Same type support as integration_list_databases/integration_list_tables, and the same schema rule: pass schema for SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP, omit it for everything else. Useful before vibe_coding_block_connect_data_source (to inspect a table before committing to it) and before writing code against an already-connected table (vibe_coding_block_get_code's dataSources entry already includes this for connected sources — use that once connected).

integration_list_tables

ChatGPT
List the tables/sheets within a specific database of a workspace data source. Returns id and name for each. Same type support as integration_list_databases. Use this before vibe_coding_block_connect_data_source to resolve a valid tableId/tableName. You must pass the schema, from integration_list_schemas, for SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP; for every other type the schema argument must be omitted. SQL and Coda results include views as well as tables — a view is readable but cannot be written to. Narrow-purpose, same caveat as integration_list_databases: for a SOFTR_TABLES source, use database_list_tables/database_list_fields/database_search_records for anything beyond resolving IDs for vibe_coding_block_connect_data_source.

report_missing_capability

ChatGPT
Tell the Softr team about something the user asked for that none of the Softr tools can do: a missing tool, a missing option on a tool, or information no tool returns. Call it after checking the available tools, when you are about to tell the user it is not possible or to work around it. Do not call it for an error, a missing permission or a bug in a tool that exists, or for something the user can do in Softr Studio themselves. It grants nothing: the capability stays unavailable in this conversation. It only records the report for the Softr product team, so write it as a short need in your own words and leave out personal data and record contents. Pass the workspaceId or applicationId you were working in when you know it.

send_feedback

ChatGPT
Send feedback to the Softr team. Pick the type that fits: - MISSING_CAPABILITY: the user asked for something none of the Softr tools can do — a missing tool, a missing option on a tool, or information no tool returns — whether or not Softr Studio offers it. Check the available tools first. - BUG_REPORT: a tool did something other than its description says, or failed in a way you could not fix by changing the arguments. Not for an error you can correct and retry, or a missing permission. Pass toolName. - UNCLEAR_DOCS: a tool did what its description says, but its description, or the output of a docs tool, left out or contradicted what you needed, so you had to guess or retry. Pass toolName. - OTHER: anything else the user asks you to pass on to Softr. Not for your own commentary. Before calling with OTHER, show the user the exact text you are about to send and ask whether to send it. Call only after they agree, with the text they approved; if they decline, do not call it. It grants nothing and fixes nothing in this conversation: it only records the feedback for the Softr product team. Write it as a short note in your own words and leave out personal data and record contents. Pass the workspaceId or applicationId you were working in when you know it.

vibe_coding_block_connect_data_source

ChatGPT
Wire a specific table or sheet, from within a workspace data source, to a vibe-coding block, making it queryable in code via hooks like useRecords()/useRecord()/mutation hooks. A block can have several data sources at once, each identified by its own dataSourceId; calling this again with the same dataSourceId on the same block replaces that connection, so treat it as a real change to the block, not a no-op re-wiring. Every data source type Softr supports can be connected. Resolve the IDs in this order: integration_list (integrationId + type), then integration_list_databases (databaseId), then — for SUPABASE, POSTGRESQL, SQL_SERVER, SNOWFLAKE, GOOGLE_BIGQUERY, SMARTSUITE and CLICKUP only — integration_list_schemas (schema), then integration_list_tables (tableId/tableName). Proxy-only integrations (Gmail, Slack, OpenAI, ...) are the only kind that cannot be connected. This only persists the data binding — it does NOT write or change any code. A brand-new block never has a datasource wired yet, and code referencing hooks like useRecords() compiles fine even before this is called, but fails at runtime until it is. Follow up with vibe_coding_block_update_code (or search-replace) to actually reference it: define a human-readable name for it via datasource.define({ <name>: "<dataSourceId>" }) (the name is just for code readability, chosen freely), then pass from: ds.<name> on hook calls — vibe_coding_block_get_code's dataSources entry for this dataSourceId will then include the resolved fields and fieldReferenceKey to use in that code. Once the code referencing it is in place, give the user the Studio link to this page — the server instructions carry the exact URL pattern — and offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_create

ChatGPT
Create a new vibe-coding (AI-generated custom code) block on an existing page and return its blockId. Use this when the user wants a brand-new custom block, as opposed to editing one that already exists (find those with application_page_get first). Pass code (and a brief task summary in userPrompt) to compile your real source directly on creation — this is the normal path when you already know what to build, and avoids a separate vibe_coding_block_update_code round-trip. Omit both to create an empty placeholder block instead (seeded with non-functional placeholder source, not blank/uncompiled) for the user to build out later via vibe_coding_block_update_code. code and userPrompt must be given together — passing one without the other is rejected. Call vibe_coding_block_get_docs before writing code, same as you would before any vibe_coding_block_update_code call — do this every time, even if you called it earlier in this conversation. Critical: a brand-new block NEVER has a datasource wired yet — vibe_coding_block_get_code's dataSources field, which you'd normally check before calling a data-fetching/mutation hook, doesn't apply here since there's nothing to check yet. Any code you pass that calls useRecords, useRecord, useMetric, useChartData, useRecordCreate/Update/Delete, or useProxyFetch will compile fine but throw at runtime. If the block needs a datasource: if you already know which table/base/API to use (the user told you, or it's the obvious single choice), create the block first (this call, with no code or only static placeholder code), then call vibe_coding_block_connect_data_source, and only then write the data-dependent code via vibe_coding_block_update_code — do not pass data-dependent code in this same call, since the datasource doesn't exist yet at creation time. If it's not clear which table to use, ask the user instead of guessing. Either way, plain static content (e.g. a memes block with hardcoded images) needs no datasource and can be written directly. Like vibe_coding_block_update_code, code is compiled server-side before saving: if compilation fails, NOTHING is created — unlike the two-call path, there's no empty block left behind to retry against, so the whole call must be repeated with fixed code. If the compiled code calls a mutation hook, the block's Actions (Studio UI's "Actions" tab) are derived from it automatically — one per (datasource x hook): useRecordCreate -> ADD_RECORD, useRecordUpdate -> UPDATE_RECORD, useRecordDelete -> DELETE_RECORD. They come back in this tool's actions field, each at its default visibility (UPDATE_RECORD and DELETE_RECORD are restricted to logged-in users; the rest inherit the block's own visibility). Restrict them further with vibe_coding_block_set_action_visibility if the user asked for that. The block is inserted on the page right after any header/navigation blocks. Optionally pass a title to override the default "Vibe coding block" title shown in Studio UI. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new block until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_delete

ChatGPT
Permanently remove a vibe-coding block from a page. Use this when the user wants a block gone — "delete the chart block", "remove the block you just added", "scrap it and start over" — as opposed to hiding it from some or all visitors, which is vibe_coding_block_set_visibility and leaves the block in place. Vibe-coding blocks ONLY. Find the block with application_page_get and check its type is "vibe-coding" before calling; any other block type (a header, a form, a list, a navigation bar) is rejected with an error, and there is no MCP tool that deletes one — those are deleted by the user in Studio UI. Say that rather than looking for a way around it. This is not undoable through MCP. vibe_coding_block_restore_version rolls a block that still exists back to an earlier version; it cannot bring back a deleted block, and neither can vibe_coding_block_duplicate_from_version, which needs the original block to copy from. The block's version history stops being reachable with it. If the user's goal is really "go back to how it was", that is vibe_coding_block_restore_version on the existing block — do not delete and rebuild. So confirm with the user before calling this unless they were already explicit that the block should be deleted, and if the block might still be wanted, offer vibe_coding_block_duplicate_from_version (to keep a copy) or vibe_coding_block_set_visibility (to hide it) first. Any data sources connected to the block go with it — there is no separate vibe_coding_block_disconnect_data_source call to make first. The workspace integration itself stays connected, and no other block is touched. Deleting the block does NOT publish the change: the block disappears from Studio immediately, but the live app keeps serving it until the next publish. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open still shows the block until it is reloaded. Then offer to show them the page without it with application_preview, or to make the removal live with application_publish.

vibe_coding_block_disconnect_data_source

ChatGPT
Remove a data source connection from a vibe-coding block (undoes vibe_coding_block_connect_data_source for the given dataSourceId). Only removes the data binding — it does NOT change or remove any code. Any hooks in the block's code still referencing this dataSourceId (e.g. useRecords({ from: ds.<name> })) will compile fine but fail at runtime afterward, so also update or remove that code (vibe_coding_block_update_code or search-replace) unless you're about to reconnect a different data source with the same dataSourceId right away. Once any code still referencing this dataSourceId has been updated or removed, give the user the Studio link to this page — the server instructions carry the exact URL pattern — and offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_duplicate_from_version

ChatGPT
Create a NEW vibe-coding block on the SAME page from one of an existing block's versions, leaving the original block completely untouched. Use this to fork a version — "keep both", "make a variant of the old version", "copy this block as it was before" — as opposed to vibe_coding_block_restore_version, which rolls the original block back in place and creates no new block. The copy is the whole block as that VERSION stored it — code, editable-setting values, datasource wiring and action visibility — so it reflects that version rather than how the original is configured today, and normally works immediately without a follow-up vibe_coding_block_connect_data_source. It is appended to the end of the page; move it in Studio UI if the user wants it elsewhere. Its version history starts fresh with a single entry copied from the source version. Returns the new blockId — use that, not the original, for any further edits to the copy. For an OLDER version, nothing needs checking or re-applying: the user asked for that version and the copy is that version — action visibility included — and its code, settings and wiring all come from the same capture, so they are consistent with each other. It may well differ from how the original is configured today; that is the point. For the NEWEST version (versionNumber == totalCount) it is different, because the user means "copy this block as it is now" — but even the newest version was captured at the last CODE write, so anything changed since without one is missing from the copy: action visibility, setting values and datasource wiring. Compare the original's current state against the copy — one vibe_coding_block_get_settings call on the ORIGINAL gives all three (settings, actions, dataSources) without its source code — then apply whatever differs to the NEW blockId with vibe_coding_block_update_settings / vibe_coding_block_set_action_visibility / vibe_coding_block_connect_data_source, and tell the user what you carried over. Close by giving the user the Studio link to this page — the copy sits on the same page as the original, so it is the same link, and the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new block until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_get_code

ChatGPT
Get the current source code AND current persisted editable-setting values of an existing vibe-coding (AI-generated custom code) block. Use application_page_get first to find blocks with type "vibe-coding", then call this before making any change. If you only need the setting values — e.g. right before calling vibe_coding_block_update_settings, with no code change involved — call the lighter-weight vibe_coding_block_get_settings instead, which skips the (potentially large) source code entirely. To confirm a push landed rather than to read the code, pass includeCode: false: the response then describes the stored source without carrying it. When sourceSha256 is present, compare it with the one the write tool returned, or with a SHA-256 of the text you sent; sourceBytes gives the same answer more cheaply for a length mismatch. Do not fetch the whole source just to verify it — a block routinely runs past 100 KB, and every byte of it goes through your context. Important: the returned settings list is the block's ACTUAL rendered content — it can differ from whatever initialValue is written in sourceCode, because once a setting has rendered once, its persisted value (not the code's initialValue) is what's shown. Always read settings here — never assume sourceCode's initialValue reflects current content — before calling vibe_coding_block_update_settings. Critical: the returned dataSources list is the ONLY reliable way to know whether this block actually has a datasource wired to it (via Studio UI's "Source" tab, or the vibe_coding_block_connect_data_source tool) — this is completely independent of what the code itself calls, and the server-side compile step CANNOT check it (the compiler never sees the block's datasource wiring, only the code text). If dataSources is empty, the block has NO datasource connected: any code you write that calls a data-fetching or mutation hook (useRecords, useRecord, useMetric, useChartData, useRecordCreate/Update/Delete, useProxyFetch) will compile and save successfully but then THROW AT RUNTIME in the browser (e.g. "Cannot call useRecords/useProxyFetch because this block does not have a datasource configured") — a failure this tool's compile step cannot catch or report back to you. Only use those hooks when dataSources is non-empty, and match the hook family to the entry's type: - REST_API → use useProxyFetch. The entry's baseUrl (when present) is the exact, already-configured host — inline that literal value as-is; never hardcode a different host or guess one. - Any other type (e.g. SOFTR_TABLES, AIRTABLE, GOOGLE_SHEET, ...) → a table-shaped integration: use useRecords/useRecord/useMetric/useChartData/mutation hooks. The entry's fields array (when present) already lists every current field's exact id, name, type, and (for select/linked-record/datetime/etc) type-specific options (e.g. select choices, linked table id) — read this directly to write q.select()/filter code; never guess a field reference. MANDATORY: use the entry's own fieldReferenceKey (either "id" or "name") to pick which field property goes in q.select()/filter code for THIS datasource — never assume id universally: it's accurate for SOFTR_TABLES and most other integrations, but for AIRTABLE, GOOGLE_SHEET, and NOTION specifically, fieldReferenceKey is "name", and the field's name property (not id) MUST be used instead, full stop, no exception. Using the wrong one compiles and saves fine but silently fails to create/update records or leaves the block's Actions tab unable to show which fields are used (after a write, check the returned actions entry's fields to confirm they resolved), since the compiler cannot validate a field reference against the datasource's real schema — confirmed with a real Airtable-backed block. fields/fieldReferenceKey reflect the schema at the moment of this call — if you already fetched it earlier in this conversation and significant time or other schema changes may have passed, call this tool again rather than relying on a stal…

vibe_coding_block_get_docs

ChatGPT
Fetch the CURRENT vibe-coding block framework documentation, live from docs.softr.io: the required React component contract, every available hook (data fetching — useRecords, useRecord, useMetric, useChartData; mutations — useRecordCreate, useRecordUpdate, useRecordDelete, with their exact import paths and call signatures; settings; user context; external API calls via useProxyFetch), supported libraries (Tailwind, shadcn/ui, Lucide icons, date-fns, TanStack Query, Recharts, etc.), and constraints the generated code must follow. Call this FIRST, before your first call in a conversation to vibe_coding_block_update_code or vibe_coding_block_update_code_search_replace (and ideally before vibe_coding_block_get_code too, so you already know the framework before reading the block). This documentation can change over time, so never rely on your training knowledge or an earlier turn's fetch of it — re-fetch here rather than guessing at a hook's import path or signature; guessing and trial-and-erroring against the compiler wastes many round-trips that a single call here avoids. Re-call it if you hit compile errors that suggest your understanding of the API is out of date.

vibe_coding_block_get_settings

ChatGPT
Get ONLY the current persisted editable-setting values of an existing vibe-coding (AI-generated custom code) block — a lighter-weight alternative to vibe_coding_block_get_code when you don't need the source code, e.g. right before calling vibe_coding_block_update_settings. Skips the source code entirely, which matters because vibe-coding block source can be very large — don't pay for it when all you need is a setting's current value/schema. Important: the returned settings list is the block's ACTUAL rendered content — it can differ from whatever initialValue is written in the block's source code, because once a setting has rendered once, its persisted value (not the code's initialValue) is what's shown. Always read settings here — never assume a setting's initialValue in code reflects current content — before calling vibe_coding_block_update_settings. For an array setting, note its schema too: array items must only use keys present there, and required keys must be present and non-empty. Also returns the block's actions and wired dataSources, in the same shapes vibe_coding_block_get_code uses — so this is the read for anything about a block EXCEPT its code. actions gives the ADD_RECORD/UPDATE_RECORD/DELETE_RECORD capabilities with their dataSourceId, mapped fields, permission and isDefaultVisibility; dataSources gives the wiring with each entry's type, fieldReferenceKey, fields, sortOptions and condition. That makes it the cheap read before vibe_coding_block_set_action_visibility, vibe_coding_block_set_data_source_sort, vibe_coding_block_set_data_source_record_filters and vibe_coding_block_disconnect_data_source, and for checking whether a restore or duplicate kept the visibility and wiring you expected. Only reach for vibe_coding_block_get_code when you actually need the source. If you also need the source code or wired datasources (e.g. you're about to write/edit code, not just update a setting value), call vibe_coding_block_get_code instead — it returns settings alongside source code and dataSources in one call.

vibe_coding_block_list_versions

ChatGPT
List a vibe-coding block's version history, newest first. Every successful code write (vibe_coding_block_update_code, vibe_coding_block_update_code_search_replace, vibe_coding_block_create) records one version; settings, action-visibility and datasource changes do NOT, so they never appear here as entries of their own. A version is a complete copy of the block at the INSTANT of that code write — code, setting values, datasource wiring and action visibility all included, and restoring or duplicating brings all of them back. By default each entry carries that version's OWN sourceCode, so comparing versions or recovering code needs no follow-up call. Since the code is included the response grows with history, so it is capped at limit (default 10, newest first): totalCount is the FULL history size and returned what this response holds, so when they differ you are seeing only part of the history — truncated by limit, or narrowed by versionId. To reach further back, do NOT just raise limit — that drags every newer version's code along. Survey with includeCode: false (metadata only, safe for hundreds of versions), then read the one you want by versionId. The two steps are needed because a version id can only be learned here. A null sourceCode means you passed includeCode: false. The NEWEST version is what the block is serving right now: every code write appends the version it just made live, and a restore appends a copy of the version it rolled back to. That is the first entry of an unfiltered listing, and in any response it is the one whose versionNumber equals totalCount — which is how to spot it when versionId narrowed the response to something else. prompt is the verbatim instruction that produced the version, truncated when long (promptTruncated: true); title is its name — either the versionName a caller passed or an LLM-generated summary of the prompt. CRITICAL — versionNumber is what the user sees, and it counts the OPPOSITE way to this list. It is exactly the "Version N" label in Studio UI's dropdown: numbered from the OLDEST, so version 1 is the oldest and the newest is versionNumber = totalCount. This list is newest-first, so its first entry has the HIGHEST number. Never identify a version by its position here ("the first one", "#1") — the user would read that as the opposite. Say "Version <versionNumber>", and read "version 5" as versionNumber: 5, NOT the 5th entry. The number is positional, not an identifier, and shifts as history grows: use it to TALK to the user, and always pass versionId to act. So identify the version by versionNumber/title/prompt/createdAt, then hand its versionId to vibe_coding_block_restore_version (roll this block back) or vibe_coding_block_duplicate_from_version (fork it into a new block).

vibe_coding_block_restore_version

ChatGPT
Roll a vibe-coding block back to one of its earlier versions, found via vibe_coding_block_list_versions. Use this when the user wants to undo a change, go back to a version that worked, or revert an experiment — it is the correct tool for "undo", never a hand-written attempt to retype the old code via vibe_coding_block_update_code. This does NOT recompile: it re-points the block at that version's already-compiled output, so it cannot fail with compile errors the way a code write can. History is never truncated — the restored content is appended as a NEW version on top (titled "Restored: <old title>"), returned as newVersionId. So anything that is itself in a version can be recovered by restoring that one, and a restore is undoable. A version is a complete copy of the block taken at ONE INSTANT, the code write that created it. So a restore brings back that version's action visibility, datasource wiring and setting values too, not just its code — that is intended, since rolling back to a version means the whole block as it was. Do NOT re-apply the current visibility afterwards to "preserve" it: that would produce old code with new permissions, a state that never existed and the user did not ask for. The catch is that a version captures an instant, not the period it was live, and visibility, wiring and setting changes create no version of their own. So a change made SINCE the newest version exists only on the live block: a restore discards it and no version can bring it back, not even the newest one, which predates it. When the block has actions, read their current permission first with vibe_coding_block_get_settings, compare with this tool's returned actions, and if any changed, TELL the user in concrete terms ("the Add-record button went from Admins-only to logged-in users"). Report it; don't silently re-apply. Only set it back with vibe_coding_block_set_action_visibility if the user asks after being told. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the restored code until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_set_action_visibility

ChatGPT
Set the visibility of one or more of a vibe-coding block's Actions — Studio UI's "Actions" tab, per-action "Button visibility" panel ("Who can see this button"). This is the ONLY way to configure action permissions: they live in the block's configuration, never in its source code, and code can only observe the outcome through each mutation hook's read-only enabled flag. Writing or editing code can never set them. Address each action by actionType — plus dataSourceId when the block has several actions of that type — and NEVER by action id: ids are regenerated by every code compile, so one read before a code change is already stale after it. Read the current actions from vibe_coding_block_get_code, or vibe_coding_block_get_settings which omits the source, first. Each update REPLACES that action's entire permission; anything you omit is cleared, so always send the complete intended state rather than a delta. Per entry in updates: - actionType (required): "ADD_RECORD", "UPDATE_RECORD" or "DELETE_RECORD". - dataSourceId (optional): required only when the block has more than one action of that type — i.e. the same mutation used against several wired datasources. - predefinedGroup (required): "ALL_USERS", "LOGGED_IN_USERS" or "NON_LOGGED_IN_USERS". - customGroups (optional): list of user-group IDs, from application_list_user_groups. Valid ONLY together with predefinedGroup: "LOGGED_IN_USERS". - recordCondition (optional): {"logicalOperator": "AND"|"OR", "expressions": [...]} — a per-record rule for which records the action is offered on. Valid ONLY for UPDATE_RECORD and DELETE_RECORD, which act on an existing record; ADD_RECORD has no record in context and rejects it. Every expression is exactly {"subject": {"field": "<field id or name>", "type": "TEXT" | "NUMERIC" | "BOOLEAN" | "DATE" | "ARRAY"}, "operator": "<e.g. IS, IS_NOT, CONTAINS, IS_ONE_OF, GT, LT, IS_EMPTY, ... matching the subject's type>", "value": ["..."]} — the same shape vibe_coding_block_set_data_source_record_filters takes. Those three keys are the whole contract, and any other key is rejected rather than ignored. value is ALWAYS present and ALWAYS an array of strings — pass [] for the unary IS_EMPTY / IS_NOT_EMPTY. To compare against the logged-in user, put the reference in value — never in subject.field — and use one of the forms below verbatim. Pass at least one expression: to leave the action without a record condition, omit recordCondition rather than sending an empty list. A value entry is either a literal or one of these placeholders, and NOTHING else resolves: - "{USER:::EMAIL}" and "{USER:::EMAIL_DOMAIN}" — the logged-in user's email / email domain. Braces are part of these two, and these two are the only braced form. - "USER:::<field name>" — any other field on the app's user table, e.g. "USER:::signUpDate". No braces here; get the field names from application_get_user_connection. An invented spelling is NOT a placeholder — it is stored as literal text, so the condition compares the field against that string and matches nobody. A few known-wrong ones ("LOGGED_IN_USER_EMAIL", "CURRENT_USER_EMAIL") are rejected outright, but most cannot be told apart from a value meant literally and so are stored without complaint: get them right here rather than relying on the error. The rules below are the same ones Studio UI enforces, and a violation is rejected outright: - The operator must belong to the subject's type. TEXT: IS, IS_NOT, CONTAINS, DOES_NOT_CONTAINS, IS_ONE_OF, IS_NONE_OF, STARTS_WITH, ENDS_WITH, IS_EMPTY, IS_NOT_EMPTY. NUMERIC: IS, IS_NOT, GT, LT, GTE, LTE, BETWEEN, IS_EMPTY, IS_NOT_EMPTY. BOOLEAN: IS, IS_NOT, IS_EMPTY, IS_NOT_EMPTY. ARRAY: IS, IS_ONE_OF, IS_NONE_OF, HAS_ALL_OF, IS_EMPTY, IS_NOT_EMPTY — note ARRAY has no CONTAINS and no IS_NOT, so "not one of these options" is IS_NONE_OF. DATE: IS, IS_NOT, LT, GT, LTE, GTE, IS_WITHIN, IS_NOT_WITHIN, IS_EMPTY, IS_NOT_EMPTY. - value arity follows the operator: [] for IS_EMPTY / IS_NOT_EMPTY, exactly 2 for BETWEEN (lower, upper), at least 1 for every other operator. - A D…

vibe_coding_block_set_data_source_record_filters

ChatGPT
Set the record-visibility filter for a data source already connected to a vibe-coding block (see vibe_coding_block_connect_data_source) — matches Studio UI's "Source" tab "Record filters" (conditional filters) setting. This restricts which records the connected hooks (useRecords/useRecord/useMetric/etc.) can ever see for this data source — it is NOT a per-call query filter; code can still narrow further with its own where on top of this. What you pass REPLACES the data source's current filters entirely rather than adding to them, and the previous ones are not kept, so send the full set you want — dropping a filter here widens what end users can see. Pass an empty expressions list (with any logicalOperator) to clear all filters. Each expression: {"subject": {"field": "<field id or name>", "type": "TEXT" | "NUMERIC" | "BOOLEAN" | "DATE" | "ARRAY"}, "operator": "<e.g. IS, IS_NOT, CONTAINS, GT, LT, IS_EMPTY, ..., matching the subject's type>", "value": ["..."]}. Those three keys are the whole contract, and any other key is rejected rather than ignored. value is always present and always an array of strings ([] for the unary IS_EMPTY / IS_NOT_EMPTY). Use the connected data source's fieldReferenceKey (from vibe_coding_block_get_code's dataSources) to decide whether "field" should be the field's id or its name. The operator must be one the subject's type allows — TEXT: IS, IS_NOT, CONTAINS, DOES_NOT_CONTAINS, IS_ONE_OF, IS_NONE_OF, STARTS_WITH, ENDS_WITH, IS_EMPTY, IS_NOT_EMPTY; NUMERIC: IS, IS_NOT, GT, LT, GTE, LTE, BETWEEN, IS_EMPTY, IS_NOT_EMPTY; BOOLEAN: IS, IS_NOT, IS_EMPTY, IS_NOT_EMPTY; ARRAY: IS, IS_ONE_OF, IS_NONE_OF, HAS_ALL_OF, IS_EMPTY, IS_NOT_EMPTY (no CONTAINS, no IS_NOT — "not one of these" is IS_NONE_OF); DATE: IS, IS_NOT, LT, GT, LTE, GTE, IS_WITHIN, IS_NOT_WITHIN, IS_EMPTY, IS_NOT_EMPTY. value arity follows the operator: [] for IS_EMPTY / IS_NOT_EMPTY, exactly 2 for BETWEEN, at least 1 otherwise. A DATE value is a structured token, never prose — "PREDEFINED:TODAY", "FIXED_DATE:DAYS_AGO:<n>", "FIXED_DATE:DAYS_FROM_NOW:<n>" or "YYYY-MM-DD" for the single-date operators, and "RELATIVE_DATE:THIS:<WEEK|MONTH|QUARTER|YEAR>" or "RELATIVE_DATE:LAST:<n>" / "RELATIVE_DATE:NEXT:<n>" for IS_WITHIN / IS_NOT_WITHIN — THIS takes a calendar period, LAST/NEXT take a whole number of days. To compare a field against the logged-in user rather than a fixed value, a value entry takes "{USER:::EMAIL}" or "{USER:::EMAIL_DOMAIN}" (the only braced forms), or "USER:::<field name>" for any other field on the app's user table (no braces; field names from application_get_user_connection). An invented spelling is stored as literal text and silently matches nobody. A few known-wrong ones ("LOGGED_IN_USER_EMAIL", "CURRENT_USER_EMAIL") are rejected, but most cannot be told apart from a value meant literally, so do not rely on the error. Then give the user the Studio link to this page — the server instructions carry the exact URL pattern — and offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_set_data_source_sort

ChatGPT
Set the default sort order for a data source already connected to a vibe-coding block (see vibe_coding_block_connect_data_source) — matches Studio UI's "Source" tab "Default sort" setting. This controls the order records come back in by default; code can still override it per call by passing its own orderBy to useRecords(). What you pass REPLACES the data source's current sort entirely rather than adding to it, and the previous order is not kept, so send the full list you want. Pass an empty list to clear the default sort. Each entry: {"field": "<field id or name>", "direction": "asc" | "desc"}. Use the connected data source's fieldReferenceKey (from vibe_coding_block_get_code's dataSources) to decide whether "field" should be the field's id or its name — the same rule as for query/filter code. Then give the user the Studio link to this page — the server instructions carry the exact URL pattern — and offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_set_visibility

ChatGPT
Control WHO can see a vibe-coding block and on WHICH DEVICES it renders — the block's Visibility settings in Softr Studio. Use this for "only logged-in users should see this", "restrict this to the Admins group", "hide this on mobile", or "show this to visitors who aren't signed in". This changes visibility only. It is not the tool for changing what the block shows or does (use vibe_coding_block_update_settings for content values, or vibe_coding_block_update_code / vibe_coding_block_update_code_search_replace for behavior), and it does not filter which RECORDS the block displays — for that, use vibe_coding_block_set_data_source_record_filters. Call application_page_get_block first to read the block's current visibility and visibleDevices. Every parameter is optional and each one you OMIT is left exactly as it is, so you can change devices without restating the user groups and vice versa. predefinedUserGroup must be one of ALL_USERS, LOGGED_IN_USERS, or NON_LOGGED_IN_USERS. A block may not enable all three — application_page_get_block's visibility.enabledPredefinedUserGroupTypes lists the ones it accepts, and anything else is rejected. customUserGroupIds narrows a block further, to specific groups of logged-in users, and is ONLY valid together with LOGGED_IN_USERS — either set predefinedUserGroup to LOGGED_IN_USERS in the same call, or make sure the block is already gated to it. Call application_list_user_groups to turn a group NAME the user mentioned into its ID; only groups of type CUSTOM can be used here. The list fully replaces the block's current groups, so include the ones you want to keep. An empty list clears the group restriction and is always allowed — pass it alongside predefinedUserGroup: ALL_USERS to reopen a previously restricted block to everyone. devices must be a subset of laptop, tablet, mobile, and also fully replaces the current list — every device you leave out is a device the block is HIDDEN on. To hide a block on mobile only, pass ["laptop", "tablet"]. An empty list is rejected, since it would hide the block everywhere. A block sitting inside a column container does not own its visibility — it inherits the container's — so those requests are rejected. You cannot resolve that yourself: a container is not a vibe-coding block, so this tool cannot set its visibility either, and no tool here can move a block out of a container. When you hit this, stop and tell the user to either set the visibility on the column container itself in Softr Studio, or move the block out of the container there. Do not retry against the container's ID and do not apply the restriction to a different block instead. This does not recompile code and does not create a version-history snapshot. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new visibility until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_update_code

ChatGPT
Fully replace the source code of an existing vibe-coding (AI-generated custom code) block — for creating a block from scratch, restructuring/reordering JSX, changes that span multiple areas at once (imports + hooks + handlers + JSX), or adding data-mutation functionality (create/update/delete records). For a small, localized edit (button text, a class name, a prop, a rename, a couple of lines) use vibe_coding_block_update_code_search_replace instead: it sends only the touched text, not the whole file. Do NOT use this for a pure CONTENT/DATA change to a setting that already exists (e.g. "add more items to the list", "change the title text") — recompiling code does not update an already-initialized setting's persisted value (see vibe_coding_block_get_settings), so the change will compile and save but not actually render. Use vibe_coding_block_update_settings instead for those. The block must already exist — call application_page_get/vibe_coding_block_get_code first to find its ID and current code. Before calling any data-fetching or mutation hook (useRecords, useRecord, useMetric, useChartData, useRecordCreate/Update/Delete, useProxyFetch), check vibe_coding_block_get_code's dataSources field — if it's empty, this block has no datasource wired and those hooks will compile fine but throw at runtime in the browser. The compile step run by this tool cannot detect this, since it never sees the block's datasource wiring, only the code text. If it's empty, do NOT search database_list/database_list_tables/database_search_records for a name-matching table to use instead — stop and ask the user to specify a table/API or wire one to this block first; never silently substitute an unconnected table just because its name resembles the app or request. Conversely, if dataSources is non-empty, that IS the datasource to use, exactly as given — even if its name looks unrelated to the app or task (common in copied/test workspaces). A mismatched-looking name is never a reason to search for or substitute a different table. MANDATORY when writing q.select()/filter code against a table-shaped datasource: use the entry's own fieldReferenceKey ("id" or "name", from vibe_coding_block_get_code's dataSources) to decide which field property to reference — never assume id universally: it's accurate for SOFTR_TABLES and most integrations, but for AIRTABLE, GOOGLE_SHEET, and NOTION specifically, fieldReferenceKey is "name" and the field's name (not id) MUST be used instead. Using the wrong one compiles and saves fine but silently fails to create/update records at runtime and leaves the Actions tab unable to show which fields are used. Adding or removing a mutation hook changes the block's Actions (Studio UI's "Actions" tab): the compile step derives exactly one action per (datasource x hook) — useRecordCreate -> ADD_RECORD, useRecordUpdate -> UPDATE_RECORD, useRecordDelete -> DELETE_RECORD — and a mutation hook whose action is missing is disabled at runtime and throws when called. This tool's returned actions field is the post-compile state; check it to confirm the mutations you wrote came out live and with the right fields. MANDATORY — a code change RESETS action visibility. Compiling deletes and recreates every action with new IDs and DEFAULT permissions, silently discarding any visibility the user configured in the Actions tab. So whenever the block has actions with isDefaultVisibility: false: record each one's actionType, dataSourceId and permission from vibe_coding_block_get_code BEFORE calling this, then re-apply them afterwards with vibe_coding_block_set_action_visibility — flattening each saved permission into that tool's top-level keys, which is the shape it takes — and tell the user which actions you restored. Diff against this tool's returned actions rather than issuing another read. If an action is gone because you deliberately removed its hook, report that instead of trying to restore it. Define any content that could reasonably vary or be reused across instances of this block (titles, im…

vibe_coding_block_update_code_search_replace

ChatGPT
Apply one or more targeted search-and-replace edits to an existing vibe-coding block's source code — for small, localized changes (button text, a class name, a prop value, a variable rename, a few added/removed lines) where rewriting the whole file with vibe_coding_block_update_code is not needed. Only the touched text is sent, not the entire source. Do NOT use this for a pure content/data value change on an existing setting (use vibe_coding_block_update_settings) or for structural changes that reorder/restructure JSX, span multiple areas at once, or add data-mutation functionality (use vibe_coding_block_update_code for those). Call vibe_coding_block_get_code first to see the exact current source. If your edit touches a hook call, import, or anything else framework-related (not just plain JSX/text/class names), call vibe_coding_block_get_docs first too, every time — do not rely on memory or an earlier fetch, since the documentation can change and using a stale or guessed signature will fail to compile. If your edit adds or changes a field reference inside a q.select() call, use the target datasource's own fieldReferenceKey (from vibe_coding_block_get_code's dataSources) to decide whether to write the field's id or its name — never assume id universally. This is "name", not "id", for AIRTABLE, GOOGLE_SHEET, and NOTION specifically. Getting this wrong compiles and saves fine but silently fails to create/update records at runtime. MANDATORY — this recompiles, and a recompile RESETS action visibility. Even an edit that doesn't touch a mutation hook deletes and recreates every one of the block's Actions with new IDs and DEFAULT permissions, silently discarding visibility the user configured in the Actions tab. So whenever the block has actions with isDefaultVisibility: false: record each one's actionType, dataSourceId and permission from vibe_coding_block_get_code BEFORE calling this, re-apply them afterwards with vibe_coding_block_set_action_visibility — flattening each saved permission into that tool's top-level keys, which is the shape it takes — and tell the user which actions you restored. This tool's returned actions field is the post-compile state — diff against it rather than issuing another read. Each operation's "search" string must match the current code EXACTLY (including whitespace/indentation) and is replaced only at its FIRST occurrence — include enough surrounding context to make the match unique, and replace a complete logical unit (a whole JSX element, function call, or statement) rather than a fragment within one. Operations are applied in order, each against the result of the previous one. Like vibe_coding_block_update_code, the result is compiled server-side before saving: a search string that doesn't match, or code that fails to compile, is NOT persisted — the block keeps its previous working version — and this tool returns the failure so you can adjust and retry. A successful save also records a version-history snapshot tagged with the brief task summary, named either by versionName if you passed one or by an LLM summary of userPrompt otherwise. The returned versionId is THIS new version, not an undo handle — to revert, list the history and restore the version below it. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new compiled code until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

vibe_coding_block_update_settings

ChatGPT
Update the persisted CONTENT VALUE of one or more existing editable settings on a vibe-coding block. It skips compilation entirely. Use it for "add/remove/change items in the list", "change this text", "swap this image", "toggle this on", or any other pure value swap on a setting that already exists — text, longText, image, video, vibeCodingBlockIcon, navigation, select, array, or boolean. Each setting is identified by its NAME (the string passed to useTextSetting/useArraySetting/etc in the source code) and MUST already exist on the block — this tool cannot create new settings or change behavior/layout; use vibe_coding_block_update_code (new settings/schema changes) or vibe_coding_block_update_code_search_replace (small code tweaks) for those instead. Call vibe_coding_block_get_settings first to see each setting's current persisted value, type, and (for array settings) its schema — it skips the (potentially large) source code entirely. For an array setting, pass the FULL new array — it fully replaces the persisted value, so include the existing items you want to keep alongside any new ones. Array items must only use keys present in the setting's schema; schema keys marked required must be present and non-empty in every item. This does not recompile code and does not create a version-history snapshot — but setting values ARE part of a version (they live in the block), so vibe_coding_block_restore_version reverts them along with the code, back to whatever they were when that version was captured. Two consequences: a restore can undo a content change you made with this tool, and a change made since the newest version was captured is not in any version at all, so no restore can bring it back. If the user may want the current value back later, read it first — history won't have it. Close by giving the user the Studio link to this page — the server instructions carry the exact URL pattern — noting that a Studio tab they already have open won't show the new setting value until it is reloaded. Then offer to show them the app with application_preview or make it live with application_publish.

workflow_add_branch_node

ChatGPT
Adds a Branch step after an existing node. The step splits the workflow into branches that run in parallel, and each branch starts with its own FILTER node, which holds the branch condition. Name the branches in branchTitles, from left to right, and the command creates one branch for each name. The result lists the new FILTER node ids in the same order in newFilterNodeIds, so the first step of each branch uses one of them as its initiateId. To add a branch to an existing Branch step, use workflow_create_branch. To rename an existing branch, use workflow_rename_node on its FILTER node, because a note is not a branch name. Rules: - BRANCH is not composite - use parent's compositeNodeId This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"newNodeId":{"type":"string"},"newFilterNodeIds":{"type":"array","items":{"type":"string"}}},"required":["newNodeId","newFilterNodeIds"]}

workflow_create

ChatGPT
Creates a new workflow in a workspace, starting from the chosen trigger, and saves it at once. Use it for any automation, whatever starts it. Add the action steps afterwards with workflow_add_node and fill in their inputs with workflow_update_node_inputs. It only creates the workflow definition: no step runs until one is tested (workflow_test_node, workflow_test) or the workflow is published with workflow_publish and its trigger fires. Returns workflowId, triggerId and a url that opens the workflow in Softr Studio. This tool opens nothing by itself, so give the user the url. A webhook trigger also returns the webhookUrl it listens at, and some triggers return a hint about how to get test data. The trigger type sets the workflow's shape. Record-watch, schedule and webhook triggers get a plain workflow. SOFTR_APPS_TRIGGER_WORKFLOW (a workflow an app runs on demand from a "Run custom workflow" button) also gets the built-in Show Wait Screen and End User Interactions steps and returns initiateId. Add its first real step after initiateId with workflow_add_node, never before it or in place of those built-in steps.

workflow_create_branch

ChatGPT
Adds one more branch to an existing Branch step, at the right end. The new branch starts with a FILTER node, and the result returns its id in newFilterNodeId, so the first step of the branch uses it as its initiateId. To create a new Branch step with several named branches at once, use workflow_add_branch_node with branchTitles. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"newFilterNodeId":{"type":"string"}},"required":["newFilterNodeId"]}

workflow_delete_node

ChatGPT
Removes a specified node from the workflow along with all its associated paths. Rules: - Never delete triggers - Search ALL levels when finding nodes: workflow.actions AND inside each LOOP_ACTION_GROUP.inputs.actions - Use paths to find execution order: workflow.paths for top-level, loop.inputs.paths for inside loops - LOOP nodes delete their internal actions but NOT downstream nodes - if there are nodes after a LOOP, you still need commands for those - When deleting multiple nodes in a single response, NEVER include the same node ID twice in the array - Delete all nodes after X means only delete nodes downstream of X, bottom-up and right-to-left. NEVER include the X node itself in deleted nodes. - CRITICAL If you can't clearly identify the exact node to be deleted, NEVER guess and NEVER try to find the closest match. ALWAYS ask user to clarify. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"deletedNodeId":{"type":"string"}},"required":["deletedNodeId"]}

workflow_duplicate_node

ChatGPT
Creates an exact copy of a specified node and inserts it immediately after the original node in the workflow. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"newNodeId":{"type":"string"}},"required":["newNodeId"]}

workflow_get

ChatGPT
Returns { workflow, nodeSamples } — workflow is the full graph as raw JSON (triggers, actions, paths, and every node id); nodeSamples shows which nodes already have a tested sample output (status, hasOutput) and which do not. Re-read this whenever you need real node ids for a subsequent command (e.g. after workflow_add_node, before workflow_update_node_inputs) or are unsure of the current graph shape. Untested data-producing nodes (missing from nodeSamples, or hasOutput: false) need workflow_test_node (or workflow_test) before their outputs can be referenced via {outputs.<nodeId>:::…}. webhookUrls maps each Webhook trigger id to the URL it listens at.

workflow_get_dynamic_input_options

ChatGPT
Fetches the live allowed values for a node input whose options are not in the specification: DYNAMIC_SELECT / DYNAMIC_MULTI_SELECT inputs (a Slack channel, a Trello board and its list, a Gmail label, a Brevo contact list, …) and DYNAMIC_KEY_VALUE_LIST inputs (an integration-defined field set, e.g. Brevo contact attributes), both fetched from the connected integration; and AI_MODEL_SELECT inputs (e.g. model on SOFTR_AI_SUMMARIZE_TEXT / SOFTR_AI_SEND_PROMPT), fetched from the workspace's live AI model list. workflow_get_node_specifications only declares that such an input is dynamic (or, for AI_MODEL_SELECT, just that its value is a model name) — it never lists the values, and they differ per workspace and per connected account, so you MUST call this tool and then pass a returned value verbatim. Never invent one and never send a human-readable label or a guessed marketing name (e.g. claude-sonnet, gpt-4o-mini). Omit inputName for an inventory of the node's dynamic inputs, each with the sibling inputs it depends on and whether it is ready to fetch: the integration-backed inputs form a dependency chain (integrationId first, then e.g. idBoard, then idList) and must be filled and saved in that order, while AI_MODEL_SELECT inputs have no dependencies and are always ready. Returns status: "BLOCKED" with unresolvedParameters when a dependency is still unset — set it via workflow_update_node_inputs (or pass it in pendingInputs) and call again. For AI_MODEL_SELECT, a node whose saved value is a now-deprecated model shows that value in currentValue even though it won't appear among options — that is expected, not a bug; leave it as-is unless the user asks to change it.

workflow_get_node_output

ChatGPT
Reads a node's saved sample output and its ready-to-paste variables without re-running it. For a step inside a loop it reads the row of one iteration, and nextSteps says so. Returns status: 'NOT_TESTED' if the node has no saved sample yet — call workflow_test_node first. A step inside a loop with no row of its own falls back to its top-level sample, and nextSteps warns that the sample can be stale. Returns status: 'BLOCKED' with nextSteps only when no sample exists at any scope — ask the user to test that loop in the workflow builder. Omit nodeId to get a tested/untested overview of every node in the workflow, useful for planning which nodes still need workflow_test_node before you can wire their outputs into other nodes' inputs.

workflow_get_run

ChatGPT
Returns one run of a workflow (an id from workflow_list_runs) with every step it executed, in order: each step's title, status, input, output and errorMessage. Use it to find out why a run failed or what it did. Long strings and arrays in input and output are cut, as in workflow_get_node_output. A loop step does not list its iterations; its output holds totalIterations. Its innerSteps has one row per step inside it, nested loops included: statusCounts over every iteration, and failedAt, the iterationContext of its first 10 failures (<loopId>:<iteration>, joined by / per nesting level). failedIterationSteps holds the full data of up to 5 failures, one per failing step before a second of the same step, and failedIterationStepsOmitted counts the rest. Pass any failedAt entry with its actionId to workflow_get_run_step for that iteration. The tool opens up to 20 runs of nested loops; nestedLoopsNotInspected counts those left unopened, whose steps are missing from innerSteps. The steps are those of the workflow version the run executed (run.workflowVersion), which can differ from the workflow's current version. A run is recorded only when the published workflow runs, so a workflow that was never published has none: publish it with workflow_publish. Tests from workflow_test_node and workflow_test are not runs; read their results with workflow_get_node_output. Unpublishing keeps the runs already recorded. workflow_list_runs leaves out runs older than the workspace plan's log retention (7 to 90 days).

workflow_get_run_step

ChatGPT
Returns one step of a run with its full input, output and errorMessage, cut as in workflow_get_run. Use it for an iteration workflow_get_run did not include: pass the step's actionId and an iterationContext from its failedAt, or build one for any other iteration (<loopId>:<iteration>, iterations count from 0, up to the loop's totalIterations). Leave iterationContext out for a step outside any loop. A loop step comes back with the innerSteps summary of its own iterations, so nested loops can be read one level at a time.

workflow_get_url

ChatGPT
Returns url — the link that opens this workflow in the studio workflow builder. It activates the workflow's own workspace on load, so the user lands in the right place with no workspace switching. Call this whenever you report a workflow as built, published, or needing something finished by hand, and give the user the link — never just a workflow id.

workflow_guide

ChatGPT
Call before working on a workflow: returns the instructions for building, testing and publishing one. Call it once per conversation, before describing or calling any other workflow tool. Skip it if this guide is already in your server instructions. Not needed for app, page or database work.

workflow_list

ChatGPT
Lists the workflows in a workspace, most recently updated first. Use to find a workflow's id by title. Pass at least one of workspaceId or applicationId.

workflow_list_runs

ChatGPT
Lists a workflow's runs, the execution logs shown on its Runs tab in Softr Studio, newest first, 20 per page. Each run has its id, status, startTimestamp, stepCountSucceeded and stepCountFailed. A FINISHED status does not mean every step succeeded: check stepCountFailed. Pass a run id to workflow_get_run to see what each step received, returned and why it failed. Pass nextOffset back as offset for the next page; it is null on the last page. A run is recorded only when the published workflow runs, so a workflow that was never published has none: publish it with workflow_publish. Tests from workflow_test_node and workflow_test are not runs; read their results with workflow_get_node_output. Unpublishing keeps the runs already recorded. workflow_list_runs leaves out runs older than the workspace plan's log retention (7 to 90 days).

workflow_rename

ChatGPT
Updates the title of the workflow to a new value. Rules: - Use for workflow-level renaming, not node renaming This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"newTitle":{"type":"string"}},"required":["newTitle"]}

workflow_rename_node

ChatGPT
Updates the title of a specified node in the workflow. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"renamedNodeId":{"type":"string"}},"required":["renamedNodeId"]}

workflow_reorder_branches

ChatGPT
Changes the left-to-right order of the branches of a BRANCH node. The current order is the order of the BRANCH node's paths to its FILTER nodes. A branch letter (A, B, C) names a position in that order. The command moves whole branches: each FILTER node keeps its title, its condition and the steps after it. The letters and the step numbers follow the new positions, so a moved branch takes the letter of its new place. The order is visual only, because all qualifying branches run in parallel. Use this command when the user asks to move a branch or gives a new branch order. To move steps between branches or inside a branch, use workflow_reorder_node or workflow_reorder_multiple_nodes instead. They cannot change the branch order. To add a branch, use workflow_create_branch. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"branchNodeId":{"type":"string"}},"required":["branchNodeId"]}

workflow_reorder_multiple_nodes

ChatGPT
Reorders multiple nodes within the workflow, optionally deleting nodes after reordering. Rules: - If any node not found, return message with available nodes - DO NOT use the optional nodeIdsToDeleteAfterReorder parameter for combined move+delete, this property is only meant for the command execution from UI. If any nodes should be cleaned up after moving other nodes, use a dedicated command to delete those. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"success":{"type":"boolean"}},"required":["success"]}

workflow_reorder_node

ChatGPT
Reorders the specified node to appear relative to a reference node within the workflow. Rules: - Use this command only to move a single node. To reorder a group of consequent nodes at once, use a dedicated command. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs.

workflow_replace_trigger_node

ChatGPT
Replaces the workflow trigger with a different trigger type. Rules: - Use only for triggers, not actions (use workflow_replace_node for actions) - nodeId must be a trigger id already present in the provided workflow (triggers[0].id) — never a newly generated id This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"newNodeId":{"type":"string"}},"required":["newNodeId"]} A workflow node is a step stored in the workflow definition, and its type names the kind of step (e.g. GMAIL_SEND_EMAIL is a "Send email" step). This tool only edits that definition — it sends nothing to, and changes nothing in, any connected app. Softr's workflow engine runs the step when the published workflow's trigger fires, or when it is tested with workflow_test_node or workflow_test.

workflow_unpublish

ChatGPT
Unpublishes (disables) a workflow so it stops running on its trigger. The workflow and its steps are kept, only disabled.

workflow_update_configuration

ChatGPT
Updates the workflow's configuration: localization (timezone, date/time and number formats) and execution settings such as serial execution. Rules: - Use for workflow-level configuration changes only — never for node inputs or workflow rename This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs.

workflow_update_filter_node_condition

ChatGPT
Sets or clears the condition of a FILTER node. A FILTER is the gate in front of a branch or a stretch of a workflow: the steps after it run only when its condition is true, and a FILTER without a condition always passes. The condition is stored on the path that leaves the FILTER node, and this command is how it is written. Provide condition to replace the existing condition, or omit it to remove the condition. workflow_add_branch_node creates one FILTER per branch and returns their ids as newFilterNodeIds; workflow_create_branch adds one more branch to an existing BRANCH node and returns its FILTER id as newFilterNodeId. To make a branch conditional, emit this command once for each of those FILTER ids, after the branch exists. There is no else-branch: every branch whose condition is true runs, and a branch without a condition always runs. A branch that must run only "otherwise" needs the negated condition of the other branches. The condition is a group (AND or OR) whose items are rules or nested groups; a rule compares a left side with a right side using an operator. Use workflow_add_branch_node or workflow_create_branch to create branches and workflow_update_node_inputs to configure steps; none of them writes a FILTER's condition. Rules: - Pick the operator from the data type of the compared value (a path condition's left side or a data-source field). Every type except Boolean also takes IS_EMPTY and IS_NOT_EMPTY: Text: IS, IS_NOT, CONTAINS, DOES_NOT_CONTAIN, STARTS_WITH, DOES_NOT_START_WITH, ENDS_WITH, DOES_NOT_END_WITH, IS_ONE_OF, IS_NOT_ONE_OF Single select: IS, IS_NOT, IS_ONE_OF, IS_NOT_ONE_OF Number: IS, IS_NOT, GREATER_THAN, GREATER_THAN_OR_EQUALS, LESS_THAN, LESS_THAN_OR_EQUALS, IS_BETWEEN, IS_NOT_BETWEEN Boolean: IS with true or false List (multi-select, attachments, a [*] path, a multi-value step output): HAS_ANY_OF, HAS_ALL_OF, HAS_NONE_OF, IS (exact match) Date: IS (on), IS_NOT, LESS_THAN, LESS_THAN_OR_EQUALS, GREATER_THAN, GREATER_THAN_OR_EQUALS, IS_WITHIN, IS_NOT_WITHIN - A condition's dates (a path condition or a record filter) are ISO strings in the workflow's time zone or {dateTime:::<TOKEN>} tokens such as {dateTime:::TODAY}, {dateTime:::7_DAYS_FROM_NOW} or {dateTime:::NEXT_WEEK_END}, one ISO date or one token per side or bound. IS_WITHIN and IS_NOT_WITHIN take only two ISO dates or the preset pair of a named period: this week {dateTime:::THIS_WEEK} to {dateTime:::NEXT_WEEK_START}, this month {dateTime:::THIS_MONTH} to {dateTime:::NEXT_MONTH_START}, this year {dateTime:::THIS_YEAR} to {dateTime:::NEXT_YEAR_START}, last week {dateTime:::PAST_WEEK} to {dateTime:::THIS_WEEK}, and for NEXT_WEEK, NEXT_MONTH, NEXT_YEAR, PAST_MONTH and PAST_YEAR the <PERIOD>_START to <PERIOD>_END tokens. Any other window is two rules in an AND group, GREATER_THAN_OR_EQUALS the start and LESS_THAN the end; excluding it is an OR group of LESS_THAN the start and GREATER_THAN_OR_EQUALS the end. THIS_WEEK, THIS_MONTH and THIS_YEAR keep the current time of day, so never use them as the start of a GREATER_THAN_OR_EQUALS rule: the preset pair is the form for the current period - Never set a FILTER's condition through workflow_update_node_inputs — a filter or condition input on a FILTER node is ignored - Target only FILTER nodes, with a branch's id from newFilterNodeIds (workflow_add_branch_node) or newFilterNodeId (workflow_create_branch), never the BRANCH node's id - Each of leftSide, rightSide, lowerBound and upperBound is exactly one variable token or one literal — a string mixing a token with other text is compared as literal text - Variable tokens: {outputs.<nodeId>:::$.<path>} reads a step's output; {metadata.<nodeId>:::status} reads a step's run status, SUCCEEDED or FAILED; {dateTime:::<TOKEN>} is a date; inside a loop {loopActionGroup.<loopNodeId>:::loopVariables.items.<field>} is the current item. Write a token only with a verbatim node id and path you know - Reference only steps that run before the FILTER, never a step after it This…

workflow_update_node_continue_on_error

ChatGPT
Sets the continue-on-error behavior of an action. When enabled, the workflow proceeds along the action's default outgoing path even if the action fails — the failure is still recorded in run history, but it does not stop the workflow. When disabled (the default), a failing action stops the workflow. Useful for best-effort steps such as audit logs or optional notifications. Rules: - Never target a trigger or a control-flow node (BRANCH, FILTER, WAIT, LOOP_ACTION_GROUP) — the setting exists only on side-effect actions. - Never enable on an action whose outgoing path already carries a custom condition (the user's wiring must not be overwritten — remove or adjust that condition first). This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"updatedNodeId":{"type":"string"}},"required":["updatedNodeId"]}

workflow_update_node_note

ChatGPT
Updates the note of a specified node in the workflow. Rules: - Set note to null to delete the note This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"updatedNodeId":{"type":"string"}},"required":["updatedNodeId"]}

workflow_update_node_retry

ChatGPT
Sets the automatic retry of a failing action. When enabled, the engine re-runs the action after the configured wait until it succeeds or maxAttempts is reached — only the final attempt's outcome counts as the step result, so failure handling (continue-on-error paths, notifications) fires only after the last attempt. The server retries only errors it classifies as transient (rate limits, 5xx, timeouts) — auth or configuration errors fail immediately. Rules: - Never target a trigger, a control-flow node (BRANCH, FILTER, WAIT, LOOP_ACTION_GROUP, RESPONDED_TO_WEBHOOK), or an interactive action — retry exists only on side-effect actions. - Never target an action inside a loop — retry is not yet supported there. This tool saves the change to the workflow immediately. Its result contains real IDs (see resultMetadata) — use them in subsequent calls. There is no result-placeholder mechanism: never invent IDs. Result shape (JSON Schema): {"properties":{"updatedNodeId":{"type":"string"}},"required":["updatedNodeId"]}

workflow_validate

ChatGPT
Runs the workflow builder's validation over every step and reports what blocks publishing. status is READY_TO_PUBLISH or BLOCKED. issues lists every step with an incomplete setup (a required input is empty, an integration is not connected, a formula has a syntax error) or an error (a variable reference that no longer resolves, a failed test run), with the step id, its title and the message the user sees in the builder. Warnings such as "Step hasn't been tested yet" are not listed. Call it before workflow_publish, and after a change whose result carried errors.

workspace_list

ChatGPT
List the workspaces accessible to the authenticated builder. Returns id, name, and isDefault for each workspace — if the user hasn't specified which workspace to use, take the one with isDefault true rather than asking or guessing. Call this only when you need to resolve a workspace name to an ID, for example before database_create. For general discovery, use application_list instead — every application already includes its workspaceId.

workspace_list_email_senders

ChatGPT
List the email sender signatures registered on a workspace: signatureId, name, email, whether the address is confirmed, whether its domain is verified, and the DNS records (dnsRecords) the domain needs. Any app in the workspace can be assigned one of these senders with application_configure_email_sender (pass just the sender's email). An unconfirmed sender is not used yet — apps assigned to it keep sending from the default Softr address until the confirmation link sent to the sender's mailbox is clicked. The states shown are the last ones Softr checked and can be out of date; call workspace_verify_email_sender for the current ones. Use workspace_list to resolve a workspace name to an ID if needed.

workspace_verify_email_sender

ChatGPT
Check an email sender again with Softr's email provider and return its current state. It answers two separate questions: - confirmed: was the confirmation link sent to the sender's mailbox clicked? Until it is, apps keep sending from the default Softr address. - domainVerified: are the sender domain's DKIM (TXT) and Return-Path (CNAME) DNS records in place? Mail is already sent from the custom address without them, but receiving servers trust it less and may put it in spam or reject it. dnsRecords.dkim and dnsRecords.returnPath each carry verified. To set the records up, give the user both records in dnsRecords (type, host, value) to add at their DNS provider. host is relative to zone, which is what most DNS providers expect; fqdn is the full name, for providers that want one. Call this tool only after the user says the records are added. DNS changes usually show up within minutes but can take up to 24 hours; a check made before a record exists can be cached and keep failing for a while. If a record is still not verified, tell the user to wait and check later rather than calling this tool again in a loop. Use workspace_list_email_senders to find the signatureId.

add_application_user

Claude

add_branch_node

Claude

add_node

Claude

aggregate_data

Claude

configure_application_email_sender

Claude

configure_application_sign_up

Claude

connect_vibe_coding_block_data_source

Claude

create_application

Claude

create_branch

Claude

create_database

Claude

create_field

Claude

create_page

Claude

create_record

Claude

create_records

Claude

create_table

Claude

create_vibe_coding_block

Claude

create_workflow

Claude

delete_database

Claude

delete_field

Claude

delete_node

Claude

delete_record

Claude

delete_records

Claude

delete_table

Claude

disconnect_vibe_coding_block_data_source

Claude

duplicate_node

Claude

duplicate_vibe_coding_block_from_version

Claude

get_access_control

Claude

get_application

Claude

get_block

Claude

get_database

Claude

get_dynamic_input_options

Claude

get_node_output

Claude

get_node_specifications

Claude

get_page

Claude

get_page_permissions

Claude

get_record

Claude

get_schema

Claude

get_table

Claude

get_vibe_coding_block_code

Claude

get_vibe_coding_block_settings

Claude

get_vibe_coding_docs

Claude

get_workflow

Claude

get_workflow_url

Claude

get_workspace_integrations

Claude

list_applications

Claude

list_data_source_databases

Claude

list_data_source_schemas

Claude

list_data_source_table_fields

Claude

list_data_source_tables

Claude

list_data_sources

Claude

list_databases

Claude

list_fields

Claude

list_node_types

Claude

list_pages

Claude

list_records

Claude

list_tables

Claude

list_user_groups

Claude

list_vibe_coding_block_versions

Claude

list_views

Claude

list_workflows

Claude

list_workspace_email_senders

Claude

list_workspaces

Claude

preview_app

Claude

publish_app

Claude

publish_workflow

Claude

remove_application_user

Claude

rename_node

Claude

rename_workflow

Claude

reorder_multiple_nodes

Claude

reorder_node

Claude

replace_node

Claude

replace_trigger_node

Claude

restore_vibe_coding_block_version

Claude

search_records

Claude

set_application_login

Claude

set_application_user_activation

Claude

set_vibe_coding_block_action_visibility

Claude

set_vibe_coding_block_data_source_record_filters

Claude

set_vibe_coding_block_data_source_sort

Claude

set_vibe_coding_block_visibility

Claude

test_node

Claude

unpublish_workflow

Claude

update_application_data_source

Claude

update_database

Claude

update_field

Claude

update_node_continue_on_error

Claude

update_node_inputs

Claude

update_node_note

Claude

update_node_retry

Claude

update_record

Claude

update_table

Claude

update_vibe_coding_block_code

Claude

update_vibe_coding_block_code_search_replace

Claude

update_vibe_coding_block_settings

Claude

update_workflow_configuration

Claude

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps