@respira/wordpress-mcp-server 6.11.13 → 6.13.0

package/dist/server.js

@@ -58,6 +58,43 @@ class ToolTimeoutError extends Error {
 function getMaxToolTimeoutMs() {
     return Math.max(5000, parseInt(process.env.RESPIRA_MAX_TOOL_TIMEOUT_MS || '120000', 10));
 }
+/**
+ * v6.12.0: Tool names that do NOT receive the optional site_id input parameter.
+ * These tools operate on global Respira config or pre-site setup state, so a
+ * per-call site override doesn't apply:
+ *   - list_sites: returns all configured sites
+ *   - get_active_site: returns the global current site (a per-call override
+ *     would be meaningless here; if you want a specific site's summary, look
+ *     at list_sites)
+ *   - switch_site: already takes site_id with the explicit semantics of
+ *     flipping the global current site (different intent from per-call override)
+ *   - redeem_token: pre-site setup; no site exists yet
+ */
+const SITE_AGNOSTIC_TOOLS = new Set([
+    'wordpress_list_sites',
+    'wordpress_get_active_site',
+    'wordpress_switch_site',
+    'wordpress_redeem_token',
+    'respira_list_sites',
+    'respira_get_active_site',
+    'respira_switch_site',
+    'respira_redeem_token',
+]);
+/**
+ * v6.12.0: Schema fragment auto-injected into every non-agnostic tool's
+ * inputSchema.properties. Lets callers override the active site on a single
+ * tool call without flipping the global current site.
+ *
+ * Solves the Cowork multi-chat contamination: when Cowork runs many chat
+ * sessions through one shared MCP server process, switch_site mutates the
+ * global current site for all sessions. Passing site_id per call sidesteps
+ * the shared state entirely. T.S. (studioscaler) reported the symptom
+ * 2026-05-16 across his multi-site workflow.
+ */
+const SITE_ID_PROPERTY = {
+    type: 'string',
+    description: 'Optional. Override the active site for this single call without changing the global current site. Use this when running multiple Cowork chats against different WordPress sites in parallel so each chat can pin its own target site per tool call.',
+};
 export class RespiraWordPressServer {
     server;
     currentSite = null;
@@ -359,6 +396,35 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         }
         return this.getSiteSummary(this.currentSite);
     }
+    /**
+     * Resolve which WordPressClient should service this tool call.
+     *
+     * Order:
+     *   1) explicit args.site_id (per-call override; introduced in v6.12.0)
+     *   2) the global current site (`this.currentSite`)
+     *
+     * Throws if neither is set, or if the supplied site_id is unknown / not
+     * allowed for this MCP configuration group.
+     *
+     * @since 6.12.0
+     */
+    resolveClient(args) {
+        if (args && typeof args.site_id === 'string' && args.site_id.length > 0) {
+            const explicit = this.sites.get(args.site_id);
+            if (!explicit) {
+                const available = Array.from(this.sites.keys()).join(', ') || '(none configured)';
+                throw new Error(`Site with ID "${args.site_id}" not found in this MCP configuration. Available: ${available}`);
+            }
+            if (!this.isSiteAllowed(explicit)) {
+                throw new Error(`Site "${args.site_id}" is not in this MCP configuration group.`);
+            }
+            return explicit;
+        }
+        if (!this.currentSite) {
+            throw new Error('No active site. Either pass site_id on this tool call or run respira_switch_site / respira_redeem_token first.');
+        }
+        return this.currentSite;
+    }
     /** Check if a site is visible given RESPIRA_SITES filtering. */
     isSiteAllowed(site) {
         if (!this.allowedSites)
@@ -1182,7 +1248,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
             },
             {
                 name: 'wordpress_find_builder_targets',
-                description: 'List all editable builder modules/blocks on a page with their types, labels, and text content — without returning the full builder JSON. Use this for a quick overview of what is on a page. For finding a specific element by text or class, use find_element instead.',
+                description: 'List all editable builder modules/blocks on a page with their types, labels, and text content — without returning the full builder JSON. Use this for a quick overview of what is on a page. For finding a specific element by text or class, use find_element instead. Returns `total_matches` (true total independent of limit), `offset`, `has_more`, and `next_offset` for pagination. WPBakery / Uncode targets now surface a populated `label` / `admin_label` / `text` so you do not have to grep the raw shortcode preview.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -1200,16 +1266,59 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                         },
                         limit: {
                             type: 'number',
-                            description: 'Maximum number of matches to return (default 10)',
+                            description: 'Maximum number of matches to return per page (default 10). The full match count is always returned as `total_matches` independent of this limit.',
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Skip the first N matches before slicing the page. Defaults to 0. Paginate by passing the previous response\'s `next_offset` value.',
                         },
                     },
                     required: ['builder', 'page_id'],
                 },
                 readOnlyHint: true,
             },
+            {
+                name: 'wordpress_get_page_outline',
+                description: 'Row-level outline of a builder page. Lighter than extract_builder_content; one entry per top-level row with { index, type, kind, primary_heading, child_count, child_types } so you can answer "what is the structure of this page" without walking the full tree client-side. Works on every supported builder; adapters with a dedicated outline implementation (WPBakery + Uncode today) return a richer per-row child-type histogram.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        builder: {
+                            type: 'string',
+                            description: 'Builder name. Optional — auto-detected from the active site builder when omitted.',
+                        },
+                        page_id: {
+                            type: 'number',
+                            description: 'Page or post ID',
+                        },
+                    },
+                    required: ['page_id'],
+                },
+                readOnlyHint: true,
+            },
+            {
+                name: 'wordpress_get_builder_inline_schemas',
+                description: 'Per-shortcode / per-block inline attribute schemas for the requested builder. Currently populated for WPBakery + Uncode + TagDiv via vc_map() at runtime (cached as a transient for 1h). Other builders return `schemas: {}` + `supported: false` + a structured hint. Use this to discover what attributes a specific `vc_*` / `uncode_*` shortcode accepts before writing.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        builder: {
+                            type: 'string',
+                            description: 'Builder name. Optional — auto-detected from the active site builder when omitted. Pass "wpbakery" explicitly for non-WPBakery sites that want to inspect the catalog anyway.',
+                        },
+                        types: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Optional filter — only return schemas for these shortcode types (e.g. ["vc_custom_heading", "vc_button"]). Omit to return all registered schemas.',
+                        },
+                    },
+                    required: [],
+                },
+                readOnlyHint: true,
+            },
             {
                 name: 'wordpress_inject_builder_content',
-                description: 'REPLACE (or append to) the entire page builder layout. WARNING: By default this REPLACES all existing content — use mode:"append" to add content without destroying existing elements. For editing a single module, use wordpress_update_module instead. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. For Divi, divi_version is required ("4" or "5"). Starting in plugin v7.0.16, calling this against a page that already has content with mode="replace" (the default) without also passing confirm_replace=true returns a 409 respira_replace_confirmation_required — pass mode="append" to add to existing content, or pass mode="replace" AND confirm_replace=true to overwrite. The gate prevents silent data loss.',
+                description: 'REPLACE (or append to) the entire page builder layout. WARNING: By default this REPLACES all existing content — use mode:"append" to add content without destroying existing elements. For editing a single module, use wordpress_update_module instead. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. For Divi, divi_version is required ("4" or "5"). Starting in plugin v7.0.16, calling this against a page that already has content with mode="replace" (the default) without also passing confirm_replace=true returns a 409 respira_replace_confirmation_required — pass mode="append" to add to existing content, pass mode="replace" AND confirm_replace=true to overwrite, or pass edit_target="live" to overwrite the live page directly (plugin v7.0.22+ accepts an authorized live edit as the confirmation). The gate prevents silent data loss.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -2851,6 +2960,18 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         if (await this.isAcfAvailable()) {
             tools.push(...getAcfTools());
         }
+        // v6.12.0: inject optional site_id into every non-agnostic tool schema.
+        // Agnostic tools (list_sites, get_active_site, switch_site, redeem_token)
+        // skip the injection because they operate on global state.
+        for (const t of tools) {
+            if (SITE_AGNOSTIC_TOOLS.has(t.name))
+                continue;
+            if (!t.inputSchema || t.inputSchema.type !== 'object')
+                continue;
+            const props = (t.inputSchema.properties ||= {});
+            if (!props.site_id)
+                props.site_id = SITE_ID_PROPERTY;
+        }
         // Generate respira_* aliases for all wordpress_* tools.
         const allTools = this.generateDualTools(tools);
         // Context-aware tool filtering: expose only relevant tools based on
@@ -3318,9 +3439,11 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         return args;
     }
     async handleToolCall(name, args) {
-        if (!this.currentSite) {
-            throw new Error('No WordPress site configured');
-        }
+        // v6.12.0: relaxed top-of-handler guard. dispatchToolCall / resolveClient
+        // now decides whether a site is needed for THIS call (some tools are
+        // site-agnostic, others accept a per-call site_id override). The old
+        // eager `if (!this.currentSite) throw` blocked the new "call with just
+        // site_id on a server with no default site" path.
         // Normalize respira_* ↔ wordpress_* names.
         const { canonical, deprecated } = this.normalizeToolName(name);
         // mcp-v6.11.1: snake_case sweep across tool catalog. Schemas advertise
@@ -3338,14 +3461,15 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         return result;
     }
     async dispatchToolCall(name, args) {
-        if (!this.currentSite) {
-            throw new Error('No WordPress site configured');
-        }
+        // v6.12.0: per-call site resolution. Agnostic tools work without a
+        // resolved client; everything else requires either args.site_id or a
+        // global currentSite. resolveClient throws cleanly if neither is set.
+        const client = SITE_AGNOSTIC_TOOLS.has(name) ? this.currentSite : this.resolveClient(args);
         switch (name) {
             case 'wordpress_get_site_context':
                 return args.detail === 'full'
-                    ? await this.currentSite.getSiteContext()
-                    : await this.currentSite.getCompactSiteContext();
+                    ? await client.getSiteContext()
+                    : await client.getCompactSiteContext();
             case 'wordpress_list_sites': {
                 const allSites = Array.from(this.sites.values());
                 const visibleSites = allSites.filter((site) => this.isSiteAllowed(site));
@@ -3359,21 +3483,21 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                     site: this.getActiveSiteSummary(),
                 };
             case 'wordpress_get_theme_docs':
-                return await this.currentSite.getThemeDocs();
+                return await client.getThemeDocs();
             case 'wordpress_get_builder_info':
-                return await this.currentSite.getBuilderInfo({ debug: Boolean(args?.debug) });
+                return await client.getBuilderInfo({ debug: Boolean(args?.debug) });
             case 'wordpress_list_pages':
-                return await this.currentSite.listPages(args);
+                return await client.listPages(args);
             case 'wordpress_read_page':
-                return await this.currentSite.getPage(args.id, args.include);
+                return await client.getPage(args.id, args.include);
             case 'wordpress_create_page_duplicate':
                 return {
-                    ...(await this.currentSite.duplicatePage(args.original_id, args.suffix, args.include)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.duplicatePage(args.original_id, args.suffix, args.include)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_update_page': {
-                const approvalsUrl = this.currentSite.getApprovalsUrl();
-                const page = await this.currentSite.updatePage(args.id, args);
+                const approvalsUrl = client.getApprovalsUrl();
+                const page = await client.updatePage(args.id, args);
                 // Check if Respira created a duplicate
                 if (page.__respira_duplicate_info) {
                     const info = page.__respira_duplicate_info;
@@ -3394,19 +3518,19 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_delete_page':
-                return await this.currentSite.deletePage(args.id, args.force);
+                return await client.deletePage(args.id, args.force);
             case 'wordpress_list_posts':
-                return await this.currentSite.listPosts(args);
+                return await client.listPosts(args);
             case 'wordpress_read_post':
-                return await this.currentSite.getPost(args.id, args.include);
+                return await client.getPost(args.id, args.include);
             case 'wordpress_create_post_duplicate':
                 return {
-                    ...(await this.currentSite.duplicatePost(args.original_id, args.suffix, args.include)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.duplicatePost(args.original_id, args.suffix, args.include)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_update_post': {
-                const approvalsUrl = this.currentSite.getApprovalsUrl();
-                const post = await this.currentSite.updatePost(args.id, args);
+                const approvalsUrl = client.getApprovalsUrl();
+                const post = await client.updatePost(args.id, args);
                 // Check if Respira created a duplicate
                 if (post.__respira_duplicate_info) {
                     const info = post.__respira_duplicate_info;
@@ -3427,27 +3551,31 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_delete_post':
-                return await this.currentSite.deletePost(args.id, args.force);
+                return await client.deletePost(args.id, args.force);
             case 'wordpress_list_media':
-                return await this.currentSite.listMedia(args);
+                return await client.listMedia(args);
             case 'wordpress_upload_media':
-                return await this.currentSite.uploadMedia(args.file, args.filename, args.mime_type, args.title, args.alt, args.caption);
+                return await client.uploadMedia(args.file, args.filename, args.mime_type, args.title, args.alt, args.caption);
             case 'wordpress_extract_builder_content':
-                return await this.currentSite.extractBuilderContent(args.builder, args.page_id);
+                return await client.extractBuilderContent(args.builder, args.page_id);
             case 'wordpress_find_builder_targets':
-                return await this.currentSite.findBuilderTargets(args.builder, args.page_id, args.query, args.limit);
+                return await client.findBuilderTargets(args.builder, args.page_id, args.query, args.limit, args.offset);
+            case 'wordpress_get_page_outline':
+                return await client.getPageOutline(args.builder, args.page_id);
+            case 'wordpress_get_builder_inline_schemas':
+                return await client.getBuilderInlineSchemas(args.builder, args.types);
             case 'wordpress_inject_builder_content':
                 return {
-                    ...(await this.currentSite.injectBuilderContent(args.builder, args.page_id, args.content, args.divi_version, args.edit_target, args.mode, args.confirm_replace)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(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_update_module':
                 return {
-                    ...(await this.currentSite.updateModule(args.builder, args.page_id, args.module_identifier, args.updates, args.edit_target)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.updateModule(args.builder, args.page_id, args.module_identifier, args.updates, args.edit_target)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_validate_security':
-                return await this.currentSite.validateSecurity(args.content);
+                return await client.validateSecurity(args.content);
             case 'wordpress_switch_site': {
                 const newSite = this.sites.get(args.site_id);
                 if (!newSite) {
@@ -3465,7 +3593,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_diagnose_connection':
-                return await this.currentSite.diagnoseConnection({ post_id: args.post_id });
+                return await client.diagnoseConnection({ post_id: args.post_id });
             // Canonical name (normalizeToolName rewrites respira_* → wordpress_*
             // before this switch runs). The early-route guard in setRequestHandler
             // catches the redeem call before we ever land here when no site is
@@ -3475,245 +3603,245 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 return await this.redeemInstallToken(String(args.token || ''));
             // Page Speed Analysis
             case 'wordpress_analyze_performance':
-                return await this.currentSite.analyzePerformance(args.page_id);
+                return await client.analyzePerformance(args.page_id);
             case 'wordpress_get_core_web_vitals':
-                return await this.currentSite.getCoreWebVitals(args.page_id);
+                return await client.getCoreWebVitals(args.page_id);
             case 'wordpress_analyze_images':
-                return await this.currentSite.analyzeImages(args.page_id);
+                return await client.analyzeImages(args.page_id);
             // SEO Analysis
             case 'wordpress_analyze_seo':
-                return await this.currentSite.analyzeSEO(args.page_id);
+                return await client.analyzeSEO(args.page_id);
             case 'wordpress_check_seo_issues':
-                return await this.currentSite.checkSEOIssues(args.page_id);
+                return await client.checkSEOIssues(args.page_id);
             case 'wordpress_analyze_readability':
-                return await this.currentSite.analyzeReadability(args.page_id);
+                return await client.analyzeReadability(args.page_id);
             case 'wordpress_analyze_rankmath':
-                return await this.currentSite.analyzeRankMath(args.post_id);
+                return await client.analyzeRankMath(args.post_id);
             // AEO Analysis
             case 'wordpress_analyze_aeo':
-                return await this.currentSite.analyzeAEO(args.page_id);
+                return await client.analyzeAEO(args.page_id);
             case 'wordpress_check_structured_data':
-                return await this.currentSite.checkStructuredData(args.page_id);
+                return await client.checkStructuredData(args.page_id);
             // Accessibility
             case 'wordpress_list_accessibility_scans':
-                return await this.currentSite.listAccessibilityScans();
+                return await client.listAccessibilityScans();
             case 'wordpress_get_accessibility_scan':
-                return await this.currentSite.getAccessibilityScan(args.scan_id);
+                return await client.getAccessibilityScan(args.scan_id);
             case 'wordpress_scan_page_accessibility':
-                return await this.currentSite.scanPageAccessibility(args.page_id, args.standard);
+                return await client.scanPageAccessibility(args.page_id, args.standard);
             case 'wordpress_apply_accessibility_fixes':
-                return await this.currentSite.applyAccessibilityFixes(args.scan_id, args.rule_ids);
+                return await client.applyAccessibilityFixes(args.scan_id, args.rule_ids);
             // Plugin Management (EXPERIMENTAL)
             case 'wordpress_list_plugins':
-                return await this.currentSite.listPlugins();
+                return await client.listPlugins();
             case 'wordpress_install_plugin':
-                return await this.currentSite.installPlugin(args.slug_or_url, args.source || 'wordpress.org', args.approval_token);
+                return await client.installPlugin(args.slug_or_url, args.source || 'wordpress.org', args.approval_token);
             case 'wordpress_activate_plugin':
-                return await this.currentSite.activatePlugin(args.slug, args.approval_token);
+                return await client.activatePlugin(args.slug, args.approval_token);
             case 'wordpress_deactivate_plugin':
-                return await this.currentSite.deactivatePlugin(args.slug, args.approval_token);
+                return await client.deactivatePlugin(args.slug, args.approval_token);
             case 'wordpress_update_plugin':
-                return await this.currentSite.updatePlugin(args.slug, args.approval_token);
+                return await client.updatePlugin(args.slug, args.approval_token);
             case 'wordpress_delete_plugin':
-                return await this.currentSite.deletePlugin(args.slug, args.approval_token);
+                return await client.deletePlugin(args.slug, args.approval_token);
             // Users Management
             case 'wordpress_list_users':
-                return await this.currentSite.listUsers(args);
+                return await client.listUsers(args);
             case 'wordpress_get_user':
-                return await this.currentSite.getUser(args.id);
+                return await client.getUser(args.id);
             case 'wordpress_create_user':
-                return await this.currentSite.createUser(args);
+                return await client.createUser(args);
             case 'wordpress_update_user':
-                return await this.currentSite.updateUser(args.id, args);
+                return await client.updateUser(args.id, args);
             case 'wordpress_delete_user':
-                return await this.currentSite.deleteUser(args.id, args.reassign);
+                return await client.deleteUser(args.id, args.reassign);
             // Comments
             case 'wordpress_list_comments':
-                return await this.currentSite.listComments(args);
+                return await client.listComments(args);
             case 'wordpress_get_comment':
-                return await this.currentSite.getComment(args.id);
+                return await client.getComment(args.id);
             case 'wordpress_create_comment':
-                return await this.currentSite.createComment(args);
+                return await client.createComment(args);
             case 'wordpress_update_comment':
-                return await this.currentSite.updateComment(args.id, args);
+                return await client.updateComment(args.id, args);
             case 'wordpress_delete_comment':
-                return await this.currentSite.deleteComment(args.id);
+                return await client.deleteComment(args.id);
             // Taxonomies
             case 'wordpress_list_taxonomies':
-                return await this.currentSite.listTaxonomies();
+                return await client.listTaxonomies();
             case 'wordpress_get_taxonomy':
-                return await this.currentSite.getTaxonomy(args.taxonomy);
+                return await client.getTaxonomy(args.taxonomy);
             case 'wordpress_list_terms':
-                return await this.currentSite.listTerms(args.taxonomy, args);
+                return await client.listTerms(args.taxonomy, args);
             case 'wordpress_get_term':
-                return await this.currentSite.getTerm(args.taxonomy, args.id);
+                return await client.getTerm(args.taxonomy, args.id);
             case 'wordpress_create_term':
-                return await this.currentSite.createTerm(args.taxonomy, args);
+                return await client.createTerm(args.taxonomy, args);
             case 'wordpress_update_term':
-                return await this.currentSite.updateTerm(args.taxonomy, args.id, args);
+                return await client.updateTerm(args.taxonomy, args.id, args);
             case 'wordpress_delete_term':
-                return await this.currentSite.deleteTerm(args.taxonomy, args.id);
+                return await client.deleteTerm(args.taxonomy, args.id);
             // Custom Post Types
             case 'wordpress_list_post_types':
-                return await this.currentSite.listPostTypes();
+                return await client.listPostTypes();
             case 'wordpress_get_post_type':
-                return await this.currentSite.getPostType(args.type);
+                return await client.getPostType(args.type);
             case 'wordpress_list_custom_posts':
-                return await this.currentSite.listCustomPosts(args.type, args);
+                return await client.listCustomPosts(args.type, args);
             case 'wordpress_get_custom_post':
-                return await this.currentSite.getCustomPost(args.type, args.id, args.include);
+                return await client.getCustomPost(args.type, args.id, args.include);
             case 'wordpress_create_custom_post':
-                return await this.currentSite.createCustomPost(args.type, args);
+                return await client.createCustomPost(args.type, args);
             case 'wordpress_update_custom_post':
-                return await this.currentSite.updateCustomPost(args.type, args.id, args);
+                return await client.updateCustomPost(args.type, args.id, args);
             case 'wordpress_delete_custom_post':
-                return await this.currentSite.deleteCustomPost(args.type, args.id);
+                return await client.deleteCustomPost(args.type, args.id);
             // Options
             case 'wordpress_list_options':
-                return await this.currentSite.listOptions(args.search);
+                return await client.listOptions(args.search);
             case 'wordpress_get_option':
-                return await this.currentSite.getOption(args.option);
+                return await client.getOption(args.option);
             case 'wordpress_update_option':
-                return await this.currentSite.updateOption(args.option, args.value);
+                return await client.updateOption(args.option, args.value);
             case 'wordpress_delete_option':
-                return await this.currentSite.deleteOption(args.option);
+                return await client.deleteOption(args.option);
             // Media enhancements
             case 'wordpress_get_media':
-                return await this.currentSite.getMedia(args.id);
+                return await client.getMedia(args.id);
             case 'wordpress_update_media':
-                return await this.currentSite.updateMedia(args.id, args);
+                return await client.updateMedia(args.id, args);
             case 'wordpress_update_media_batch':
-                return await this.currentSite.updateMediaBatch(args.items);
+                return await client.updateMediaBatch(args.items);
             case 'wordpress_delete_media':
-                return await this.currentSite.deleteMedia(args.id);
+                return await client.deleteMedia(args.id);
             // Menu Management
             case 'wordpress_list_menus':
-                return await this.currentSite.listMenus();
+                return await client.listMenus();
             case 'wordpress_get_menu':
-                return await this.currentSite.getMenu(args.id);
+                return await client.getMenu(args.id);
             case 'wordpress_create_menu':
-                return await this.currentSite.createMenu(args);
+                return await client.createMenu(args);
             case 'wordpress_update_menu':
-                return await this.currentSite.updateMenu(args.id, args);
+                return await client.updateMenu(args.id, args);
             case 'wordpress_delete_menu':
-                return await this.currentSite.deleteMenu(args.id);
+                return await client.deleteMenu(args.id);
             // Menu Locations
             case 'wordpress_list_menu_locations':
-                return await this.currentSite.listMenuLocations();
+                return await client.listMenuLocations();
             case 'wordpress_assign_menu_location':
-                return await this.currentSite.assignMenuToLocation(args.location, args.menu_id);
+                return await client.assignMenuToLocation(args.location, args.menu_id);
             // Menu Items
             case 'wordpress_list_menu_items':
-                return await this.currentSite.listMenuItems(args.menu_id);
+                return await client.listMenuItems(args.menu_id);
             case 'wordpress_create_menu_item':
-                return await this.currentSite.createMenuItem(args.menu_id, args);
+                return await client.createMenuItem(args.menu_id, args);
             case 'wordpress_get_menu_item':
-                return await this.currentSite.getMenuItem(args.item_id);
+                return await client.getMenuItem(args.item_id);
             case 'wordpress_update_menu_item':
-                return await this.currentSite.updateMenuItem(args.item_id, args);
+                return await client.updateMenuItem(args.item_id, args);
             case 'wordpress_delete_menu_item':
-                return await this.currentSite.deleteMenuItem(args.item_id);
+                return await client.deleteMenuItem(args.item_id);
             case 'wordpress_list_snapshots':
-                return await this.currentSite.listSnapshots(args);
+                return await client.listSnapshots(args);
             case 'wordpress_get_snapshot':
-                return await this.currentSite.getSnapshot(args.snapshot_uuid);
+                return await client.getSnapshot(args.snapshot_uuid);
             case 'wordpress_diff_snapshots':
-                return await this.currentSite.diffSnapshots(args.snapshot_uuid_a, args.snapshot_uuid_b);
+                return await client.diffSnapshots(args.snapshot_uuid_a, args.snapshot_uuid_b);
             case 'wordpress_restore_snapshot':
-                return await this.currentSite.restoreSnapshot(args.snapshot_uuid);
+                return await client.restoreSnapshot(args.snapshot_uuid);
             case 'wordpress_apply_builder_patch':
-                return await this.currentSite.applyBuilderPatch(args.builder, args.post_id, args.operations, args.include, args.edit_target);
+                return await client.applyBuilderPatch(args.builder, args.post_id, args.operations, args.include, args.edit_target);
             case 'woocommerce_list_products':
-                return await this.currentSite.woocommerceListProducts(args);
+                return await client.woocommerceListProducts(args);
             case 'woocommerce_get_product':
-                return await this.currentSite.woocommerceGetProduct(args.id);
+                return await client.woocommerceGetProduct(args.id);
             case 'woocommerce_create_product':
-                return await this.currentSite.woocommerceCreateProduct(args);
+                return await client.woocommerceCreateProduct(args);
             case 'woocommerce_update_product': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateProduct(id, payload);
+                return await client.woocommerceUpdateProduct(id, payload);
             }
             case 'woocommerce_duplicate_product':
-                return await this.currentSite.woocommerceDuplicateProduct(args.id);
+                return await client.woocommerceDuplicateProduct(args.id);
             case 'woocommerce_list_categories':
-                return await this.currentSite.woocommerceListCategories(args);
+                return await client.woocommerceListCategories(args);
             case 'woocommerce_get_category':
-                return await this.currentSite.woocommerceGetCategory(args.id);
+                return await client.woocommerceGetCategory(args.id);
             case 'woocommerce_create_category':
-                return await this.currentSite.woocommerceCreateCategory(args);
+                return await client.woocommerceCreateCategory(args);
             case 'woocommerce_update_category': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateCategory(id, payload);
+                return await client.woocommerceUpdateCategory(id, payload);
             }
             case 'woocommerce_delete_category':
-                return await this.currentSite.woocommerceDeleteCategory(args.id);
+                return await client.woocommerceDeleteCategory(args.id);
             case 'woocommerce_list_tags':
-                return await this.currentSite.woocommerceListTags(args);
+                return await client.woocommerceListTags(args);
             case 'woocommerce_get_tag':
-                return await this.currentSite.woocommerceGetTag(args.id);
+                return await client.woocommerceGetTag(args.id);
             case 'woocommerce_create_tag':
-                return await this.currentSite.woocommerceCreateTag(args);
+                return await client.woocommerceCreateTag(args);
             case 'woocommerce_update_tag': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateTag(id, payload);
+                return await client.woocommerceUpdateTag(id, payload);
             }
             case 'woocommerce_delete_tag':
-                return await this.currentSite.woocommerceDeleteTag(args.id);
+                return await client.woocommerceDeleteTag(args.id);
             case 'woocommerce_list_orders':
-                return await this.currentSite.woocommerceListOrders(args);
+                return await client.woocommerceListOrders(args);
             case 'woocommerce_get_order':
-                return await this.currentSite.woocommerceGetOrder(args.id);
+                return await client.woocommerceGetOrder(args.id);
             case 'woocommerce_update_order_status':
-                return await this.currentSite.woocommerceUpdateOrderStatus(args.id, args.status);
+                return await client.woocommerceUpdateOrderStatus(args.id, args.status);
             case 'woocommerce_get_stock_status':
-                return await this.currentSite.woocommerceGetStockStatus();
+                return await client.woocommerceGetStockStatus();
             case 'woocommerce_update_stock': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateStock(id, payload);
+                return await client.woocommerceUpdateStock(id, payload);
             }
             case 'woocommerce_sales_report':
-                return await this.currentSite.woocommerceSalesReport(args);
+                return await client.woocommerceSalesReport(args);
             // --- v5.2.0 Elemental tools ---
             case 'wordpress_find_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/find/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/find/${post_id}`, rest);
             }
             case 'wordpress_update_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/update/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/update/${post_id}`, rest);
             }
             case 'wordpress_move_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/move/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/move/${post_id}`, rest);
             }
             case 'wordpress_duplicate_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/duplicate/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/duplicate/${post_id}`, rest);
             }
             case 'wordpress_remove_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/remove/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/remove/${post_id}`, rest);
             }
             case 'wordpress_batch_update': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/batch/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/batch/${post_id}`, rest);
             }
             case 'wordpress_reorder_elements': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/reorder/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/reorder/${post_id}`, rest);
             }
             case 'wordpress_build_page':
-                return await this.currentSite.callRestV2('POST', '/builder/build', args);
+                return await client.callRestV2('POST', '/builder/build', args);
             case 'wordpress_convert_html_to_builder':
-                return await this.currentSite.callRestV2('POST', '/builder/convert', args);
+                return await client.callRestV2('POST', '/builder/convert', args);
             case 'wordpress_bulk_pages_operation':
-                return await this.currentSite.callRestV2('POST', '/builder/bulk', args);
+                return await client.callRestV2('POST', '/builder/bulk', args);
             case 'wordpress_search_stock_images':
-                return await this.currentSite.callRestV2('GET', '/stock-images/search', args);
+                return await client.callRestV2('GET', '/stock-images/search', args);
             case 'wordpress_sideload_image':
-                return await this.currentSite.callRestV2('POST', '/stock-images/sideload', args);
+                return await client.callRestV2('POST', '/stock-images/sideload', args);
             case 'wordpress_get_server_compatibility':
-                return await this.currentSite.callRestV2('GET', '/server/compatibility');
+                return await client.callRestV2('GET', '/server/compatibility');
             // Widget shortcuts and Bricks tools — dynamic dispatch.
             default: {
                 // Check if this is a Bricks deep tool.
@@ -3745,7 +3873,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                         throw new Error(`Widget shortcut "${shortcutName}" requires a post_id parameter.`);
                     }
                     const { post_id: _pid, ...settings } = args;
-                    return await this.currentSite.callRestV2('POST', `/builder/widget/${shortcutName}/${postId}`, settings);
+                    return await client.callRestV2('POST', `/builder/widget/${shortcutName}/${postId}`, settings);
                 }
                 // Return isError result instead of throwing — unknown tool is an execution
                 // error, not a protocol error. This lets LLMs self-correct gracefully.