@respira/wordpress-mcp-server 6.19.11 → 7.1.1

package/dist/server.js

@@ -704,6 +704,15 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
             const direct = process.env.RESPIRA_USAGE_TOKEN?.trim();
             if (direct)
                 return direct.startsWith('Bearer ') ? direct.slice(7).trim() : direct;
+            // respira.press /mcp/report-issue accepts the top-level license key as
+            // an api-shaped bearer, but pre-v6.19.4 the MCP reporter never tried
+            // RESPIRA_LICENSE_KEY. Sites installed via the standard npx/env flow
+            // then fell through to the WordPress API key, which is valid for the
+            // plugin but not for respira.press, producing a 401 exactly when the
+            // customer was trying to file a bug.
+            const licenseKey = process.env.RESPIRA_LICENSE_KEY?.trim();
+            if (licenseKey)
+                return licenseKey.startsWith('Bearer ') ? licenseKey.slice(7).trim() : licenseKey;
             const headers = process.env.OTEL_EXPORTER_OTLP_HEADERS;
             if (headers) {
                 for (const part of headers.split(/[,|]/)) {
@@ -1220,12 +1229,27 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                     process.env.RESPIRA_DEBUG === 'true' ||
                     process.env.NODE_ENV === 'development';
                 const stack = debugEnabled && error?.stack ? error.stack : undefined;
+                // v6.21.2: surface the structured WP_Error envelope attached by
+                // wordpress-client. Pre-fix, the agent only ever saw the human
+                // message; structured fields (missing_args, required_path_keys,
+                // hint, instructions, registered_abilities_sample, destructive_tools)
+                // were dropped, breaking every error-handling skill built against
+                // the documented envelope contract. Mihai's QA run-4 caught this
+                // as the "envelope-vs-text mismatch".
+                const respiraErrorEnvelope = error && typeof error === 'object' && error.respiraErrorEnvelope
+                    ? error.respiraErrorEnvelope
+                    : undefined;
                 return {
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify({
                                 error: errorWithUpdateNotice,
+                                // Spread the structured envelope at top level so callers
+                                // reading `result.code`, `result.missing_args`, etc. find
+                                // them without nesting. Top-level keeps the contract close
+                                // to the WP_Error wire shape.
+                                ...(respiraErrorEnvelope ?? {}),
                                 site: activeSite,
                                 stack,
                                 // v6.17: every error response carries the report path so the
@@ -1356,19 +1380,19 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                 name: 'wordpress_invoke_ability',
                 description: 'Invoke an inhaled WordPress Abilities API ability through the Respira safety wrapper. ' +
                     'The wrapper snapshots the target post if the call looks like a write, runs the underlying ability, logs the call to the audit trail, and returns a structured envelope with a rollback URL when a snapshot was taken. ' +
-                    'The ability must (a) be registered on the site via wp_register_ability, AND (b) be inhaled (the admin toggled it on at Respira > MCP Abilities). Otherwise the call returns a structured 403/404 with instructions for the user. ' +
-                    'Use this to call any Yoast / Elementor / WooCommerce / ACF / Jetpack ability — anything the site has inhaled — with Respira\'s snapshot-before-write protection layered on top. ' +
-                    'Pass ability="vendor/ability-name" and args={…}. The args shape comes from the underlying ability\'s own schema; consult its documentation.',
+                    'The ability must (a) be registered on the site via wp_register_ability, AND (b) be inhaled (the admin toggled it on at Respira > MCP Abilities). Exception: abilities under the `respira-playbooks/` namespace bypass the inhale opt-in gate because the customer\'s own agent authored them on-site via respira_create_playbook (which already ran the destructive-tool refusal validator). Otherwise the call returns a structured 403/404 with instructions and a sample of the actually-registered ability names so the agent can self-correct. ' +
+                    'Use this to call any Yoast / Elementor / WooCommerce / ACF / Jetpack ability — anything the site has inhaled — plus any Playbook the agent authored, with Respira\'s snapshot-before-write protection layered on top. ' +
+                    'Pass ability="vendor/ability-name" and args={…}. IMPORTANT: the wire field is `args` here, NOT `input`. Playbook authors who reference `{{input.x}}` in their step templates are referring to the args object — Respira binds the incoming args under the name `input` inside the playbook executor. So `wordpress_invoke_ability({ability:"respira-playbooks/case-study-create", args:{client_name:"AcmeBank"}})` populates `{{input.client_name}}` inside the playbook steps.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         ability: {
                             type: 'string',
-                            description: 'Full ability name as registered, e.g. "yoast-seo/analyze-post" or "elementor/get-widget".',
+                            description: 'Full ability name as registered, e.g. "yoast-seo/analyze-post", "elementor/get-widget", or "respira-playbooks/case-study-create".',
                         },
                         args: {
                             type: 'object',
-                            description: 'Arguments to forward to the ability\'s execute handler. Shape varies per ability.',
+                            description: 'Arguments to forward to the ability\'s execute handler. Shape varies per ability — for a playbook, the args become `{{input.x}}` references inside the playbook steps. Always send as `args`, never as `input`.',
                         },
                     },
                     required: ['ability'],
@@ -1947,6 +1971,24 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                 },
                 idempotentHint: true,
             },
+            {
+                name: 'wordpress_make_responsive',
+                description: 'Make a desktop-only page mobile-correct in one call. Auto-detects the page builder, then generates tablet + mobile breakpoint overrides deterministically: scales font sizes (and injects a fluid clamp() for headings where the builder supports raw CSS), scales padding/margin with a sensible mobile floor, scales gaps, collapses multi-column grids toward 1 column on mobile, and switches horizontal flex layouts to vertical on mobile when they hold several children. Idempotent and non-destructive — it NEVER overwrites a responsive value you already set, so re-running is a no-op and hand-tuned breakpoints are preserved. Build the desktop layout first, then call this. Supported today: Bricks (full, incl. fluid clamp) and Elementor v3 (breakpoint overrides). Pass dry_run=true to preview the exact change list without writing. A snapshot is taken before any write, so the change is one-click reversible.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        page_id: {
+                            type: 'number',
+                            description: 'Page or post ID to make responsive.',
+                        },
+                        dry_run: {
+                            type: 'boolean',
+                            description: 'If true, returns the list of changes that would be applied without writing them (default: false).',
+                        },
+                    },
+                    required: ['page_id'],
+                },
+            },
             {
                 name: 'wordpress_update_module',
                 description: 'Update a specific module within a page builder page. Supports finding modules by admin_label, path, or type. Only updates the specified module while preserving all other content.',
@@ -3087,6 +3129,249 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                 },
                 readOnlyHint: true,
             },
+            // Custom Structures (v7.1) — agent-creatable CPTs, taxonomies, ACF field groups.
+            // Stored in wp_options on the WP side, registered against core via register_post_type
+            // / register_taxonomy / acf_add_local_field_group at init. Slug allowlist + reserved-slug
+            // protection on the WP side; capability check is `manage_options`. Deletions don't drop
+            // existing posts/terms — they orphan them in the DB. Delete those individually first if
+            // you want them gone permanently.
+            {
+                name: 'wordpress_create_post_type',
+                description: "Create a new Custom Post Type that the site will register on every request. Stored in wp_option respira_custom_post_types and registered via register_post_type() on init. Slug rules: lowercase letters/digits/underscores, must start with a letter, 1-20 chars, not a reserved WP/WooCommerce slug. Use case: agent provisions structure for a new content type (case studies, reviews, products) without writing PHP. After this call the type appears in wp-admin's left-nav and is queryable via wordpress_list_custom_posts and the existing post CRUD.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string', description: 'Slug (1-20 chars, lowercase, letters/digits/underscore, must start with letter). Example: "case_study".' },
+                        label: { type: 'string', description: 'Plural label, shown in wp-admin menus. Example: "Case Studies".' },
+                        singular_label: { type: 'string', description: 'Singular label. Defaults to label with trailing "s" stripped. Example: "Case Study".' },
+                        description: { type: 'string', description: 'Short description shown in wp-admin Tools UI.' },
+                        public: { type: 'boolean', description: 'Whether the post type is queryable from the front-end. Default true.' },
+                        show_in_rest: { type: 'boolean', description: 'Whether to expose via the WP REST API + Gutenberg editor. Default true.' },
+                        hierarchical: { type: 'boolean', description: 'true = page-like (parent/child). false = post-like (flat). Default false.' },
+                        menu_icon: { type: 'string', description: 'Dashicons class (e.g. "dashicons-portfolio") or a data URI. Default "dashicons-admin-post".' },
+                        supports: { type: 'array', items: { type: 'string' }, description: 'Capabilities the type supports. Common: title, editor, thumbnail, excerpt, custom-fields, author, comments, revisions. Default: title, editor, thumbnail, custom-fields.' },
+                        taxonomies: { type: 'array', items: { type: 'string' }, description: 'Existing taxonomy slugs to attach. Pass an empty array if none. To create a new taxonomy + attach it, call wordpress_create_taxonomy with post_types: [<this slug>] separately.' },
+                    },
+                    required: ['slug', 'label'],
+                },
+            },
+            {
+                name: 'wordpress_update_post_type',
+                description: 'Update a Respira-owned Custom Post Type. Only works on types created via wordpress_create_post_type (the option store remembers ownership). Use cases: change label, toggle public/hierarchical, add/remove taxonomy attachments. Slug is immutable — delete + recreate if you need a different slug.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string', description: 'Slug of the post type to update.' },
+                        label: { type: 'string' },
+                        singular_label: { type: 'string' },
+                        description: { type: 'string' },
+                        public: { type: 'boolean' },
+                        show_in_rest: { type: 'boolean' },
+                        hierarchical: { type: 'boolean' },
+                        menu_icon: { type: 'string' },
+                        supports: { type: 'array', items: { type: 'string' } },
+                        taxonomies: { type: 'array', items: { type: 'string' } },
+                    },
+                    required: ['slug'],
+                },
+            },
+            {
+                name: 'wordpress_delete_post_type',
+                description: "Delete a Respira-owned Custom Post Type. Posts of this type are NOT deleted — they stay in the database as orphans. The response includes orphaned_post_count so the agent knows how many posts to clean up via wordpress_delete_post (each requires its own approval round-trip). Refuses on slugs Respira didn't create.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string', description: 'Slug of the post type to delete.' },
+                    },
+                    required: ['slug'],
+                },
+                destructiveHint: true,
+            },
+            {
+                name: 'wordpress_list_custom_post_types',
+                description: "List every Custom Post Type Respira created via wordpress_create_post_type. Different from wordpress_list_post_types — that one enumerates EVERY registered post type (core, theme, third-party, Respira-created). This one shows only Respira-owned ones, with their full definition + creation timestamp.",
+                inputSchema: { type: 'object', properties: {} },
+                readOnlyHint: true,
+            },
+            {
+                name: 'wordpress_create_taxonomy',
+                description: "Create a new taxonomy registered against WordPress core via register_taxonomy() on init. Stored in wp_option respira_custom_taxonomies. Slug rules same as CPT (lowercase, letters/digits/underscore, 1-20 chars, must start with letter). Attach to one or more post types via the post_types array. After creation, wordpress_create_term lands new terms inside the taxonomy.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string', description: 'Slug. Example: "industry".' },
+                        label: { type: 'string', description: 'Plural label. Example: "Industries".' },
+                        singular_label: { type: 'string', description: 'Singular label. Default: label with trailing "s" stripped.' },
+                        description: { type: 'string' },
+                        post_types: { type: 'array', items: { type: 'string' }, description: 'Post type slugs to attach this taxonomy to. Example: ["case_study", "page"].' },
+                        public: { type: 'boolean', description: 'Default true.' },
+                        show_in_rest: { type: 'boolean', description: 'Default true.' },
+                        hierarchical: { type: 'boolean', description: 'true = category-like (parent/child terms). false = tag-like (flat). Default false.' },
+                    },
+                    required: ['slug', 'label'],
+                },
+            },
+            {
+                name: 'wordpress_update_taxonomy',
+                description: 'Update a Respira-owned taxonomy. Slug is immutable. Use this to add/remove post type attachments or change labels.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string' },
+                        label: { type: 'string' },
+                        singular_label: { type: 'string' },
+                        description: { type: 'string' },
+                        post_types: { type: 'array', items: { type: 'string' } },
+                        public: { type: 'boolean' },
+                        show_in_rest: { type: 'boolean' },
+                        hierarchical: { type: 'boolean' },
+                    },
+                    required: ['slug'],
+                },
+            },
+            {
+                name: 'wordpress_delete_taxonomy',
+                description: "Delete a Respira-owned taxonomy. Existing terms stay in the database (wp_terms + wp_term_taxonomy rows are preserved) but stop appearing until the taxonomy is re-registered. Response includes orphaned_term_count.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slug: { type: 'string' },
+                    },
+                    required: ['slug'],
+                },
+                destructiveHint: true,
+            },
+            {
+                name: 'wordpress_list_custom_taxonomies',
+                description: 'List every taxonomy Respira created. Different from wordpress_list_taxonomies — that one enumerates every registered taxonomy site-wide.',
+                inputSchema: { type: 'object', properties: {} },
+                readOnlyHint: true,
+            },
+            {
+                name: 'wordpress_create_acf_field_group',
+                description: "Create an ACF (Advanced Custom Fields) field group. Requires ACF (free or Pro) active on the site — call wordpress_get_site_context first to confirm. Stored in wp_option respira_custom_acf_field_groups and registered via acf_add_local_field_group() on acf/init. Use to bind structured fields (text, number, image, post relation) to specific post types via the location rules.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string', description: 'ACF group key. Defaults to "group_<uuid>" if omitted. Must start with "group_".' },
+                        title: { type: 'string', description: 'Human-readable title shown in the post edit screen.' },
+                        fields: { type: 'array', description: 'Array of ACF field definitions. Each follows ACF\'s schema: { key, label, name, type, ... }. See ACF docs for type-specific properties.', items: { type: 'object' } },
+                        location: { type: 'array', description: 'ACF location rules nested array. Example: [[{param:"post_type", operator:"==", value:"case_study"}]] = attach to case_study post type.', items: { type: 'array', items: { type: 'object' } } },
+                    },
+                    required: ['title'],
+                },
+            },
+            {
+                name: 'wordpress_update_acf_field_group',
+                description: 'Update a Respira-owned ACF field group. Use to add/remove fields, change location rules, or rename the group.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string', description: 'ACF group key.' },
+                        title: { type: 'string' },
+                        fields: { type: 'array', items: { type: 'object' } },
+                        location: { type: 'array', items: { type: 'array', items: { type: 'object' } } },
+                    },
+                    required: ['key'],
+                },
+            },
+            {
+                name: 'wordpress_delete_acf_field_group',
+                description: "Delete a Respira-owned ACF field group. Existing field values on posts stay in postmeta but stop appearing in edit screens. Restore by recreating the group with the same key.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string' },
+                    },
+                    required: ['key'],
+                },
+                destructiveHint: true,
+            },
+            {
+                name: 'wordpress_list_acf_field_groups',
+                description: 'List every ACF field group Respira created. Requires ACF active. Refuses with respira_acf_not_active otherwise.',
+                inputSchema: { type: 'object', properties: {} },
+                readOnlyHint: true,
+            },
+            // Playbooks (v7.1) — JSON workflow compositions that register themselves as Abilities.
+            // Once created, a playbook becomes callable via respira_invoke_ability under the
+            // ability id "respira-playbooks/<id>". The playbook executor runs each step against
+            // Respira's own REST handlers — same auth + audit + snapshot belt as a direct agent
+            // call. Destructive tools are refused at create-time (see respira_playbook_destructive_tool_refused).
+            {
+                name: 'wordpress_create_playbook',
+                description: "Author a Playbook — a typed JSON workflow that registers itself as a WordPress Ability and becomes a callable MCP tool. Use this to crystallize a repeatable workflow (\"create a case study\", \"publish a weekly digest\") so future invocations are one tool call instead of an instruction-by-instruction agent run. Steps run server-side; the agent sees a single typed result. Destructive tools (delete_*, restore_snapshot, apply_builder_patch) are refused at create-time — split the flow and have the agent call destructive ops directly. Use {{input.x}} and {{step_capture.field}} for templating between steps.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Stable id for this playbook. Lowercase, letters/digits/hyphens, 1-48 chars. Becomes part of the ability id (respira-playbooks/<id>). Example: "case-study-create".' },
+                        label: { type: 'string', description: 'Human-readable label shown in the wp-admin Playbooks screen and in tool list descriptions. Example: "Create Case Study".' },
+                        description: { type: 'string', description: 'One-line description shown to agents in the tool list. Example: "Creates a case study post with client name and industry."' },
+                        input_schema: { type: 'object', description: 'JSON schema for the playbook\'s input. Must be type:"object" with properties + required arrays. Validated by wp_register_ability on every invocation.' },
+                        steps: {
+                            type: 'array',
+                            description: 'Ordered list of steps. Each step is { tool, args, capture? }. tool = MCP tool name (must be in the executor allowlist; see DESTRUCTIVE_TOOLS for what is refused). args = literal values + mustache templates ({{input.x}}, {{capture_name.field}}). capture = optional name to bind this step\'s result under so later steps can reference it.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    tool: { type: 'string' },
+                                    args: { type: 'object' },
+                                    capture: { type: 'string', description: 'Optional. Bind this step\'s result under this name so later steps can reference it as {{<capture_name>.field}}.' },
+                                },
+                                required: ['tool', 'args'],
+                            },
+                        },
+                        returns: { type: 'object', description: 'Optional. Shape of the return payload. Templates resolved from input + captures. Example: { post_id: "{{post.id}}", url: "{{post.link}}" }.' },
+                    },
+                    required: ['id', 'label', 'input_schema', 'steps'],
+                },
+            },
+            {
+                name: 'wordpress_list_playbooks',
+                description: 'List every Playbook stored on this site, with id / ability_id / label / description / step count / invocation_count / last_invoked_at. Useful for "what playbooks are available" discovery before authoring a new one.',
+                inputSchema: { type: 'object', properties: {} },
+                readOnlyHint: true,
+            },
+            {
+                name: 'wordpress_get_playbook',
+                description: 'Get one Playbook\'s full definition (input_schema, steps, returns template, audit metadata). Use to read the source before updating or before invoking.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Playbook id (the value from wordpress_list_playbooks, not the ability_id).' },
+                    },
+                    required: ['id'],
+                },
+                readOnlyHint: true,
+            },
+            {
+                name: 'wordpress_update_playbook',
+                description: 'Modify an existing Playbook. Id is immutable — to change it, delete + recreate. Validation re-runs on the merged payload, so the same destructive-tool refusal applies to updates.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Playbook id to update.' },
+                        label: { type: 'string' },
+                        description: { type: 'string' },
+                        input_schema: { type: 'object' },
+                        steps: { type: 'array', items: { type: 'object' } },
+                        returns: { type: 'object' },
+                    },
+                    required: ['id'],
+                },
+            },
+            {
+                name: 'wordpress_delete_playbook',
+                description: 'Delete a Playbook. The corresponding Ability drops out of the MCP catalog on the next handshake. Existing posts/data created by past invocations are NOT touched.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Playbook id to delete.' },
+                    },
+                    required: ['id'],
+                },
+                destructiveHint: true,
+            },
             {
                 name: 'wordpress_list_custom_posts',
                 description: 'List posts of a custom post type. Each row includes author ({id, login, display_name}), taxonomies map, and featured_media alongside id/title/slug/status/date/url.',
@@ -3480,7 +3765,7 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
             },
             {
                 name: 'wordpress_delete_media',
-                description: 'Delete a media file.',
+                description: 'Delete a media file. Approval-gated since v7.1.0-beta.1 — the first call returns `code: respira_approval_required` with an `approval_token`; pass that token in the second call to confirm. Same flow as `delete_page` / `delete_user` / `delete_plugin`.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -3488,6 +3773,14 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                             type: 'number',
                             description: 'Media ID',
                         },
+                        approval_token: {
+                            type: 'string',
+                            description: 'Approval token returned by the first call. Send the exact token verbatim on the second call to confirm the deletion. Tokens are single-use, tied to the {action, media_id} pair, and expire after 5 minutes.',
+                        },
+                        force: {
+                            type: 'boolean',
+                            description: 'When true, bypasses Trash and permanently deletes the file (and any sibling thumbnails). Defaults to false. The WP default is to move the attachment to Trash; pass force=true to remove the underlying file too.',
+                        },
                     },
                     required: ['id'],
                 },
@@ -4576,6 +4869,8 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                     ...(await client.injectBuilderContent(args.builder, args.page_id, args.content, args.divi_version, args.edit_target, args.mode, args.confirm_replace)),
                     respira_approvals_url: client.getApprovalsUrl(),
                 };
+            case 'wordpress_make_responsive':
+                return await client.makeResponsive(args.page_id, args.dry_run || false);
             case 'wordpress_update_module':
                 return {
                     ...(await client.updateModule(args.builder, args.page_id, args.module_identifier, args.updates, args.edit_target)),
@@ -4760,6 +5055,53 @@ Allowlist: css, scss, less, json. PHP / JS theme writes are intentionally out of
                 return await client.listPostTypes();
             case 'wordpress_get_post_type':
                 return await client.getPostType(args.type);
+            // Custom Structures (v7.1) — agent-creatable CPTs, taxonomies, ACF field groups.
+            // All routes are under /wp-json/respira/v1/custom-structures/* on the plugin side.
+            // No dedicated wrappers on wordpress-client.ts — the generic callRestV1 forwards
+            // straight to the plugin handler which has full validation + audit-logging.
+            case 'wordpress_create_post_type':
+                return await client.callRestV1('POST', '/custom-structures/post-types', args);
+            case 'wordpress_update_post_type': {
+                const { slug, ...rest } = args;
+                return await client.callRestV1('PUT', `/custom-structures/post-types/${slug}`, rest);
+            }
+            case 'wordpress_delete_post_type':
+                return await client.callRestV1('DELETE', `/custom-structures/post-types/${args.slug}`);
+            case 'wordpress_list_custom_post_types':
+                return await client.callRestV1('GET', '/custom-structures/post-types');
+            case 'wordpress_create_taxonomy':
+                return await client.callRestV1('POST', '/custom-structures/taxonomies', args);
+            case 'wordpress_update_taxonomy': {
+                const { slug, ...rest } = args;
+                return await client.callRestV1('PUT', `/custom-structures/taxonomies/${slug}`, rest);
+            }
+            case 'wordpress_delete_taxonomy':
+                return await client.callRestV1('DELETE', `/custom-structures/taxonomies/${args.slug}`);
+            case 'wordpress_list_custom_taxonomies':
+                return await client.callRestV1('GET', '/custom-structures/taxonomies');
+            case 'wordpress_create_acf_field_group':
+                return await client.callRestV1('POST', '/custom-structures/acf-field-groups', args);
+            case 'wordpress_update_acf_field_group': {
+                const { key, ...rest } = args;
+                return await client.callRestV1('PUT', `/custom-structures/acf-field-groups/${key}`, rest);
+            }
+            case 'wordpress_delete_acf_field_group':
+                return await client.callRestV1('DELETE', `/custom-structures/acf-field-groups/${args.key}`);
+            case 'wordpress_list_acf_field_groups':
+                return await client.callRestV1('GET', '/custom-structures/acf-field-groups');
+            // Playbooks (v7.1)
+            case 'wordpress_create_playbook':
+                return await client.callRestV1('POST', '/playbooks', args);
+            case 'wordpress_list_playbooks':
+                return await client.callRestV1('GET', '/playbooks');
+            case 'wordpress_get_playbook':
+                return await client.callRestV1('GET', `/playbooks/${args.id}`);
+            case 'wordpress_update_playbook': {
+                const { id, ...rest } = args;
+                return await client.callRestV1('PUT', `/playbooks/${id}`, rest);
+            }
+            case 'wordpress_delete_playbook':
+                return await client.callRestV1('DELETE', `/playbooks/${args.id}`);
             case 'wordpress_list_custom_posts':
                 return await client.listCustomPosts(args.type, args);
             case 'wordpress_get_custom_post':