@wix/mcp 1.0.93 → 1.0.95

package/build/dts/site-widget-tools/pick-images-tool/index.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
+import { rethrowIfUnauthorized } from '../../auth/index.js';
+import { getWidgetHtml } from '../../widget-manifest.js';
+import { withJsonContent } from '../../tool-utils.js';
+import { WixFetchError } from '../../wix-fetch-error.js';
+import { defaultToolDescriptions } from '../../config/default-config.js';
+import { MEDIA_UPLOAD_URL_TOOL_NAME, PICK_IMAGES_TOOL_NAME } from '../constants.js';
+const PICK_IMAGES_WIDGET_URI = 'ui://widget/pick-images.html';
+// The widget uploads each picked file from the user's browser straight to the
+// Media Manager upload URL, so upload.wixmp.com must be reachable from it.
+const PICK_IMAGES_CSP = {
+    connectDomains: [
+        'https://upload.wixmp.com',
+        'https://static.parastorage.com'
+    ],
+    resourceDomains: [
+        'https://static.wixstatic.com',
+        'https://static.parastorage.com',
+        'data:',
+        'blob:'
+    ]
+};
+const PICKER_OPEN_TEXT = "An image picker is open in the chat. The user selects images there; they upload to the site's Media Manager, and a message with each image's media ID and URL follows. Reply with one short sentence and wait for that message. If your client shows no picker, send the images with UploadImageToWixSite as imageBase64, or ask the user for public URLs.";
+const siteIdSchema = z
+    .string()
+    .uuid('siteId must be a valid Wix site ID (UUID)');
+/**
+ * Exists only because Claude can't hand a file to a tool: recheck when it can (see
+ * config/file-params.ts), and drop or narrow this then.
+ *
+ * The image picker for clients that can't hand a file to a tool (Claude): the user
+ * picks images in a widget, which uploads them from the browser to the site's Media
+ * Manager through upload URLs from the app-only CreateWixMediaUploadUrl tool.
+ */
+export function addPickImagesTools(server, strategy, options) {
+    server.registerResource(`${PICK_IMAGES_TOOL_NAME}_RESOURCE`, PICK_IMAGES_WIDGET_URI, {}, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                _meta: { ui: { csp: PICK_IMAGES_CSP } },
+                mimeType: RESOURCE_MIME_TYPE,
+                text: getWidgetHtml({
+                    widgetId: 'pickImages',
+                    props: { renderMcpApps: true }
+                })
+            }
+        ]
+    }));
+    server.registerTool(PICK_IMAGES_TOOL_NAME, {
+        title: 'Pick Images to Upload to Wix',
+        description: options?.toolDescriptions?.[PICK_IMAGES_TOOL_NAME] ??
+            defaultToolDescriptions[PICK_IMAGES_TOOL_NAME],
+        inputSchema: {
+            siteId: siteIdSchema.describe('The site whose Media Manager receives the images.')
+        },
+        _meta: {
+            ui: {
+                resourceUri: PICK_IMAGES_WIDGET_URI,
+                visibility: ['app', 'model']
+            }
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true
+        }
+    }, async ({ siteId }, { setToolBiParams }) => {
+        setToolBiParams({ siteId });
+        return withJsonContent({
+            content: [{ type: 'text', text: PICKER_OPEN_TEXT }],
+            structuredContent: { siteId },
+            _meta: { widgetPayload: { siteId } }
+        });
+    });
+    server.registerTool(MEDIA_UPLOAD_URL_TOOL_NAME, {
+        title: 'Create Wix Media Upload URL',
+        description: `Used by the ${PICK_IMAGES_TOOL_NAME} widget: returns a one-time URL the widget uploads one picked image to. Not for direct use.`,
+        inputSchema: {
+            siteId: siteIdSchema,
+            fileName: z.string().min(1).max(200),
+            mimeType: z
+                .string()
+                .regex(/^image\//, 'Only images can be uploaded here'),
+            sizeInBytes: z.number().int().positive().optional()
+        },
+        _meta: { ui: { visibility: ['app'] } },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true
+        }
+    }, async ({ siteId, fileName, mimeType, sizeInBytes }, { setToolBiParams }) => {
+        setToolBiParams({ siteId });
+        try {
+            const authHeaders = await strategy.getSiteAuthHeaders(siteId);
+            const res = await fetch('https://www.wixapis.com/site-media/v1/files/generate-upload-url', {
+                method: 'POST',
+                headers: { ...authHeaders, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    mimeType,
+                    fileName,
+                    ...(sizeInBytes ? { sizeInBytes: String(sizeInBytes) } : {})
+                })
+            });
+            if (!res.ok) {
+                throw new WixFetchError(res.status, res.statusText, await res.text());
+            }
+            const { uploadUrl } = (await res.json());
+            if (!uploadUrl) {
+                throw new Error('Wix returned no upload URL');
+            }
+            // The URL is a one-time upload grant: never in the text content, which BI
+            // records as the result preview. _meta carries it for hosts that drop
+            // structuredContent.
+            return {
+                content: [{ type: 'text', text: 'Upload URL created.' }],
+                structuredContent: { uploadUrl },
+                _meta: { uploadUrl }
+            };
+        }
+        catch (error) {
+            rethrowIfUnauthorized(error);
+            await strategy.enforceValidWixToken?.(error);
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to create an upload URL: ${message}`
+                    }
+                ]
+            };
+        }
+    });
+}
+//# sourceMappingURL=index.js.map

package/build/dts/site-widget-tools/search-site-templates-tool/index.js

@@ -6,7 +6,7 @@ import { Type, TemplateBuilder } from '@wix/ambassador-funnel-templates-gallery-
 import { getWidgetHtml } from '../../widget-manifest.js';
 import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
 import { defaultToolDescriptions } from '../../config/default-config.js';
-import { SEARCH_SITE_TEMPLATES_TOOL_NAME, CREATE_SITE_FROM_TEMPLATE_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP } from '../constants.js';
+import { EDITOR_NOT_REQUESTED_MESSAGE, NOT_REQUESTED_WIDGET_PAYLOAD, SEARCH_SITE_TEMPLATES_TOOL_NAME, CREATE_SITE_FROM_TEMPLATE_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP } from '../constants.js';
 import { withJsonContent } from '../../tool-utils.js';
 // baseURL pins the host so the ambassador resolves to the public template-search
 // endpoint: https://www.wix.com/_api/template-cms-view-service/view/v2/templates/search
@@ -21,7 +21,8 @@ const BLANK_CANVAS_IMAGE_URL = 'https://images-wixmp-530a50041672c69d335ba4cf.wi
 const BLANK_CANVAS_DESCRIPTION = 'This Blank Canvas Responsive Template is ready to be customized to your exact needs.';
 const BLANK_CANVAS_META_SITE_ID = {
     studio: 'fe86a14e-ef67-49b4-a409-d086f3abaa1a',
-    harmony: '91532250-8835-46ac-9666-e4db8770b275'
+    harmony: '91532250-8835-46ac-9666-e4db8770b275',
+    classic: 'b55bdf43-95e0-4cef-b9bb-92dcc7af2742'
 };
 /**
  * Searches Wix templates server-side. Widget clients render a gallery to pick from
@@ -55,9 +56,9 @@ export function addSearchSiteTemplatesTool(server, _authStrategy, options) {
             defaultToolDescriptions[SEARCH_SITE_TEMPLATES_TOOL_NAME],
         inputSchema: {
             builder: z
-                .enum(['harmony', 'studio'])
+                .enum(['harmony', 'studio', 'classic'])
                 .default('harmony')
-                .describe('Which builder\'s templates to return: "studio" if the user asked for Wix Studio in this site creation flow, otherwise "harmony" (the default). You choose this from the request — don\'t ask the user which builder.'),
+                .describe('Which builder\'s templates to return: "studio" if the user asked for Wix Studio in this site creation flow, "classic" if they asked for the Classic Editor (the Wix Editor), otherwise "harmony" (the default). You choose this from the request — don\'t ask the user which builder.'),
             query: z
                 .string()
                 .min(1)
@@ -68,7 +69,11 @@ export function addSearchSiteTemplatesTool(server, _authStrategy, options) {
                 .min(1)
                 .max(MAX_TEMPLATE_RESULTS)
                 .optional()
-                .describe(`Maximum number of templates to return (capped at ${MAX_TEMPLATE_RESULTS}).`)
+                .describe(`Maximum number of templates to return (capped at ${MAX_TEMPLATE_RESULTS}).`),
+            templatesExplicitlyRequested: z
+                .boolean()
+                .optional()
+                .describe("Did the user, in their own words or their answer to your question, ask for a template, Wix Studio, or the Classic Editor by name? Wanting Wix's editor, or to design the site themselves, is not that: ask them how to start first. Nor are a site's business, features or look.")
         },
         _meta: {
             ui: {
@@ -85,6 +90,16 @@ export function addSearchSiteTemplatesTool(server, _authStrategy, options) {
             idempotentHint: true
         }
     }, async (args, { panorama }) => {
+        // Only an explicit false is refused: clients that hold the previous definition never send the flag.
+        if (args.templatesExplicitlyRequested === false) {
+            return withJsonContent({
+                content: [
+                    { type: 'text', text: EDITOR_NOT_REQUESTED_MESSAGE }
+                ],
+                structuredContent: { success: false, status: 'not_requested' },
+                _meta: { widgetPayload: NOT_REQUESTED_WIDGET_PAYLOAD }
+            });
+        }
         const limit = args.limit ?? MAX_TEMPLATE_RESULTS;
         console.log(`[${SEARCH_SITE_TEMPLATES_TOOL_NAME}] 🚀 tool invoked`, {
             builder: args.builder,
@@ -185,10 +200,19 @@ function blankCanvasCard(builder) {
     };
 }
 async function searchSiteTemplates(builder, query, limit) {
-    // Studio is selected via bookType; Harmony via the templateBuilders filter.
-    const builderParams = builder === 'harmony'
-        ? { filter: { templateBuilders: [TemplateBuilder.Harmony] } }
-        : { bookType: 'studio' };
+    // Studio is selected via bookType; Harmony and the Classic Editor via the
+    // templateBuilders filter (bookType "main-v2" now returns Harmony templates).
+    const builderParams = builder === 'studio'
+        ? { bookType: 'studio' }
+        : {
+            filter: {
+                templateBuilders: [
+                    builder === 'classic'
+                        ? TemplateBuilder.Editor
+                        : TemplateBuilder.Harmony
+                ]
+            }
+        };
     const response = await httpClient.request(searchTemplates({
         language: 'en',
         query: query.trim(),

package/build/dts/site-widget-tools/site-builder-tool/index.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { createHttpClient } from '@wix/http-client';
 import { getWidgetHtml } from '../../widget-manifest.js';
 import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
-import { SITE_BUILDER_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP, OPENAI_WIDGET_MIME_TYPE } from '../constants.js';
+import { EDITOR_NOT_REQUESTED_MESSAGE, NOT_REQUESTED_WIDGET_PAYLOAD, SITE_BUILDER_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP, OPENAI_WIDGET_MIME_TYPE } from '../constants.js';
 import { defaultToolDescriptions } from '../../config/default-config.js';
 import { withJsonContent } from '../../tool-utils.js';
 const httpClient = createHttpClient();
@@ -67,7 +67,11 @@ export function addCreateSiteWidgetTool(server, authStrategy, options) {
             suggestedSiteName: z
                 .string()
                 .optional()
-                .describe('You must provide this on every call, including updates to an existing job, in English. A short name for the site: the business name the user gave, or one you derive from the site prompt.')
+                .describe('You must provide this on every call, including updates to an existing job, in English. A short name for the site: the business name the user gave, or one you derive from the site prompt.'),
+            wixEditorExplicitlyRequested: z
+                .boolean()
+                .optional()
+                .describe("Did the user, in their own words or their answer to your question, ask for the Wix Harmony Editor, or for Wix to design the site? Wanting Wix's editor, or to design the site themselves, is not that: ask them how to start first. Nor are a site's business, features or look.")
         },
         _meta: toolDefinitionMeta,
         annotations: {
@@ -77,6 +81,22 @@ export function addCreateSiteWidgetTool(server, authStrategy, options) {
         }
     }, async (args, { setToolBiParams, panorama }) => {
         const isAnonymous = authStrategy.isAnonymous?.() ?? false;
+        // A new build runs unless the agent says the user did not ask for it. Only an explicit
+        // false is refused: clients that hold the previous definition never send the flag, and
+        // resuming a job does not ask again.
+        if (!args.jobId && args.wixEditorExplicitlyRequested === false) {
+            return withJsonContent({
+                content: [
+                    { type: 'text', text: EDITOR_NOT_REQUESTED_MESSAGE }
+                ],
+                structuredContent: {
+                    success: false,
+                    status: 'not_requested',
+                    jobId: null
+                },
+                _meta: { widgetPayload: NOT_REQUESTED_WIDGET_PAYLOAD }
+            });
+        }
         console.log(`[${SITE_BUILDER_TOOL_NAME}] 🚀 tool invoked`, {
             ...args,
             isAnonymous

package/build/dts/site-widget-tools/site-creation-tool/index.d.ts

@@ -1,6 +1,12 @@
 import { McpAuthenticationStrategy } from '../../auth/index.js';
 import { WixMcpServer } from '../../wix-mcp-server.js';
 import { SiteWidgetToolOptions } from '../site-builder-tool/index.js';
-/** Entry tool for the site creation flow — opens the "create with AI" vs. "use a template" chooser widget when the build method is unstated. */
+/**
+ * WixSiteCreation no longer opens a chooser. It keeps its name, so a client that still holds
+ * the previous definition never gets "tool not found", and it answers with where a new site
+ * goes: written in code and uploaded. Its definition carries no widget. The widget resource
+ * stays registered for clients whose frozen definition still points at it (ChatGPT until
+ * OpenAI approves this one); it renders a one-line card with a button that restarts the turn.
+ */
 export declare function addWixSiteCreationTool(server: WixMcpServer, _authStrategy: McpAuthenticationStrategy, options?: SiteWidgetToolOptions): void;
 //# sourceMappingURL=index.d.ts.map

package/build/dts/site-widget-tools/site-creation-tool/index.js

@@ -1,27 +1,22 @@
 import { z } from 'zod';
-import { v4 as uuidv4 } from 'uuid';
 import { getWidgetHtml } from '../../widget-manifest.js';
 import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
-import { WIX_SITE_CREATION_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP, buildSiteCreationSelectorMessage, SITE_CREATION_CUSTOM_ACTIONS_GUIDANCE } from '../constants.js';
+import { WIX_SITE_CREATION_TOOL_NAME, SITE_WIDGET_MCP_CSP, OPEN_AI_SITE_WIDGET_CSP, SITE_CREATION_ROUTE_MESSAGE } from '../constants.js';
 import { defaultToolDescriptions } from '../../config/default-config.js';
 import { withJsonContent } from '../../tool-utils.js';
 const WIX_SITE_CREATION_WIDGET_URI = 'ui://widget/wix-site-creation.html';
-/** Entry tool for the site creation flow — opens the "create with AI" vs. "use a template" chooser widget when the build method is unstated. */
+/**
+ * WixSiteCreation no longer opens a chooser. It keeps its name, so a client that still holds
+ * the previous definition never gets "tool not found", and it answers with where a new site
+ * goes: written in code and uploaded. Its definition carries no widget. The widget resource
+ * stays registered for clients whose frozen definition still points at it (ChatGPT until
+ * OpenAI approves this one); it renders a one-line card with a button that restarts the turn.
+ */
 export function addWixSiteCreationTool(server, _authStrategy, options) {
-    const toolDefinitionMeta = {
-        ui: {
-            resourceUri: WIX_SITE_CREATION_WIDGET_URI,
-            visibility: ['app', 'model']
-        },
-        securitySchemes: [{ type: 'oauth2', scopes: ['offline_access'] }],
-        'openai/toolInvocation/invoking': 'Opening site creation...',
-        'openai/toolInvocation/invoked': 'Ready',
-        'openai/outputTemplate': WIX_SITE_CREATION_WIDGET_URI
-    };
     const resourceMeta = {
         ui: { csp: SITE_WIDGET_MCP_CSP },
         'openai/widgetCSP': OPEN_AI_SITE_WIDGET_CSP,
-        'openai/widgetDescription': 'Renders the Wix site creation step: either a chooser (create with AI vs. pick a template) or a gallery of Wix Studio templates to preview and use.'
+        'openai/widgetDescription': 'Says the site is being built here in chat, with a button that continues the conversation.'
     };
     server.registerResource(`${WIX_SITE_CREATION_TOOL_NAME}_RESOURCE`, WIX_SITE_CREATION_WIDGET_URI, {}, async (uri) => {
         console.log(`[${WIX_SITE_CREATION_TOOL_NAME}] Resource requested`, {
@@ -46,25 +41,23 @@ export function addWixSiteCreationTool(server, _authStrategy, options) {
         title: 'Wix Site Creation',
         description: options?.toolDescriptions?.[WIX_SITE_CREATION_TOOL_NAME] ??
             defaultToolDescriptions[WIX_SITE_CREATION_TOOL_NAME],
+        // The previous definition's parameters, all optional, so a call made from it still validates.
         inputSchema: {
             query: z
-                .string()
-                .min(1)
-                .describe('The few most important keywords describing the site, used to search templates — e.g. "yoga studio", "wedding photographer".'),
-            sitePrompt: z
-                .string()
-                .min(1)
-                .describe('The prompt to build the site. If not provided, the user will be asked to provide a prompt.'),
-            suggestedSiteName: z
                 .string()
                 .optional()
-                .describe('Suggested site name based on the request, used alongside sitePrompt if the user picks "Create with AI".'),
-            customActions: z
+                .describe('A few keywords describing the site.'),
+            sitePrompt: z
                 .string()
                 .optional()
-                .describe(SITE_CREATION_CUSTOM_ACTIONS_GUIDANCE)
+                .describe('A description of the site.'),
+            suggestedSiteName: z.string().optional().describe('A site name.'),
+            customActions: z.string().optional().describe('Unused.'),
+            editorChosen: z.boolean().optional().describe('Unused.')
+        },
+        _meta: {
+            securitySchemes: [{ type: 'oauth2', scopes: ['offline_access'] }]
         },
-        _meta: toolDefinitionMeta,
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,
@@ -72,34 +65,12 @@ export function addWixSiteCreationTool(server, _authStrategy, options) {
             idempotentHint: true
         }
     }, async (args) => {
-        console.log(`[${WIX_SITE_CREATION_TOOL_NAME}] 🚀 tool invoked`, {
+        console.log(`[${WIX_SITE_CREATION_TOOL_NAME}] routed to the code path`, {
             query: args.query
         });
-        const widgetPayload = {
-            query: args.query,
-            sitePrompt: args.sitePrompt,
-            suggestedSiteName: args.suggestedSiteName,
-            viewUUID: uuidv4(),
-            extras: server.getWidgetExtras()
-        };
-        // Reply instruction: a fixed SHAPE (question + the two options + a "Next up:" line) built
-        // from the query (site type) and the inferred customActions, with the two option lines left
-        // for the model to tailor to the industry. Returned as-is; the tool description also
-        // instructs the model to write it out (both are load-bearing). Microsoft Copilot gets the
-        // message without the preamble: its safety filter blocks the reply otherwise.
-        const message = buildSiteCreationSelectorMessage(args.query, args.customActions, { plain: server.isMicrosoftCopilotClient() });
         return withJsonContent({
-            content: [
-                {
-                    type: 'text',
-                    text: message
-                }
-            ],
-            structuredContent: {
-                success: true,
-                query: args.query
-            },
-            _meta: { widgetPayload }
+            content: [{ type: 'text', text: SITE_CREATION_ROUTE_MESSAGE }],
+            structuredContent: { success: true, route: 'code' }
         });
     });
 }

package/build/dts/site-widget-tools/suggested-domain-tool/index.js

@@ -31,11 +31,14 @@ export function addSuggestedDomainTool(server, authStrategy) {
     server.registerTool(GET_SUGGESTED_DOMAINS_TOOL_NAME, {
         title: 'Get Suggested Domains',
         description: dedent `
-        Suggests available domain names for a business, brand, or Wix site.
+        Suggests domain name ideas for a business, brand, or Wix site. Returns a list of domain names related to the input.
 
-        Call this when the user asks for domain name ideas, wants to know which domains are available, or wants a domain for a new or existing site.
+        Call this when the user:
+        - asks for domain name ideas in general, e.g. "domain ideas for a bakery"
+        - wants to find a domain for their site, new or existing
+        - wants alternatives or variations of a domain name, e.g. "something similar to mybakery.com"
 
-        Provide either a free-text \`query\` (the user's own words, e.g. "pancakes business", "modern yoga studio") OR a \`siteId\` to base the suggestions on that site's name. At least one of them is required.
+        Provide either a free-text \`query\` (e.g. "pancakes business", "modern yoga studio") OR a \`siteId\` to base the suggestions on that site's name. At least one of them is required.
 
         Present the returned domains to the user as a short list. This tool only suggests domains — it does not purchase or connect them.
       `,

package/build/dts/support/index.d.ts

@@ -1,4 +1,8 @@
 import { WixMcpServer } from '../wix-mcp-server.js';
 import { McpAuthenticationStrategy } from '../auth/index.js';
+/** Sends one issue to Wix's feedback channel. */
+export declare const REPORT_ISSUE_TOOL_NAME = "ReportIssueToWix";
+/** The tool's former name, still honored in disableTools and toolDescriptions. */
+export declare const LEGACY_REPORT_ISSUE_TOOL_NAME = "SupportAndFeedback";
 export declare function addSupportTool(server: WixMcpServer, strategy: McpAuthenticationStrategy, disableTools?: string[], toolDescriptions?: Record<string, string>): void;
 //# sourceMappingURL=index.d.ts.map

package/build/dts/support/index.js

@@ -7,19 +7,25 @@ import { rethrowIfUnauthorized } from '../auth/index.js';
 // mcp-serverless /feedback web function — relays the message to the
 // #mcp-user-feedback Slack channel, attributed to the calling user.
 const FEEDBACK_API_URL = 'https://www.wixapis.com/mcp-serverless/v1/feedback';
+/** Sends one issue to Wix's feedback channel. */
+export const REPORT_ISSUE_TOOL_NAME = 'ReportIssueToWix';
+/** The tool's former name, still honored in disableTools and toolDescriptions. */
+export const LEGACY_REPORT_ISSUE_TOOL_NAME = 'SupportAndFeedback';
 export function addSupportTool(server, strategy, disableTools = [], toolDescriptions) {
-    if (disableTools.includes('SupportAndFeedback')) {
+    if (disableTools.includes(REPORT_ISSUE_TOOL_NAME) ||
+        disableTools.includes(LEGACY_REPORT_ISSUE_TOOL_NAME)) {
         return;
     }
-    server.tool('SupportAndFeedback', toolDescriptions?.['SupportAndFeedback'] ??
-        defaultToolDescriptions.SupportAndFeedback, (() => {
-        const d = desc('SupportAndFeedback');
+    server.tool(REPORT_ISSUE_TOOL_NAME, toolDescriptions?.[REPORT_ISSUE_TOOL_NAME] ??
+        toolDescriptions?.[LEGACY_REPORT_ISSUE_TOOL_NAME] ??
+        defaultToolDescriptions.ReportIssueToWix, (() => {
+        const d = desc('ReportIssueToWix');
         return {
             message: z.string().describe(d.message),
             requestId: z.string().optional().describe(d.requestId)
         };
     })(), { readOnlyHint: false, destructiveHint: false, openWorldHint: false }, async ({ message, requestId }, { httpClient, setToolBiParams }) => {
-        logger.log(`[SupportAndFeedback] sending feedback${requestId ? `, requestId=${requestId}` : ''}`);
+        logger.log(`[ReportIssueToWix] sending report${requestId ? `, requestId=${requestId}` : ''}`);
         const fullMessage = requestId
             ? `${message}\n\nrequest id: ${requestId}`
             : message;
@@ -37,7 +43,7 @@ export function addSupportTool(server, strategy, disableTools = [], toolDescript
                 content: [
                     {
                         type: 'text',
-                        text: 'Feedback sent to Wix. Let the user know it was delivered — note that feedback cannot be replied to or tracked.'
+                        text: 'Report sent to Wix. Let the user know it was delivered — note that reports cannot be replied to or tracked.'
                     }
                 ]
             };
@@ -55,7 +61,7 @@ export function addSupportTool(server, strategy, disableTools = [], toolDescript
                 }
             }
             setToolBiParams({ requestId: feedbackRequestId });
-            const errorMessage = `Failed to send feedback to Wix: ${error}.${errorDetails}${feedbackRequestId ? ` Request ID: ${feedbackRequestId}` : ''}`;
+            const errorMessage = `Failed to send the report to Wix: ${error}.${errorDetails}${feedbackRequestId ? ` Request ID: ${feedbackRequestId}` : ''}`;
             logger.error(errorMessage);
             throw new Error(errorMessage);
         }

package/build/dts/toolkit-entry.d.cts

@@ -107,7 +107,8 @@ declare const VALID_DOCS_TOOLS: readonly [
 	"VELO",
 	"BUSINESS_SOLUTIONS",
 	"CLI",
-	"OVERVIEW"
+	"OVERVIEW",
+	"HELP_CENTER"
 ];
 export type DocsTool = (typeof VALID_DOCS_TOOLS)[number];
 /**
@@ -126,9 +127,12 @@ export interface ReadmeDocConfig {
 }
 export interface DocsToolsOptions {
 	getToKnowWixEnabled?: boolean;
+	/** @deprecated CreateWixBusinessGuide was removed (StartHeadlessBuild replaces its headless route); ignored. */
 	createWixBusinessGuideEnabled?: boolean;
 	/** StartDeployWebsite (publish ready-made site files) — an account-owner flow; off for visitor servers. */
 	startDeployWebsiteEnabled?: boolean;
+	/** StartHeadlessBuild (build a new site in code) — an account-owner flow; off for visitor servers. */
+	startHeadlessBuildEnabled?: boolean;
 	disableTools?: string[];
 	/** Custom descriptions for tools, keyed by tool name */
 	toolDescriptions?: Record<string, string>;
@@ -148,17 +152,27 @@ export interface DocsToolsOptions {
 	commitHash?: string;
 	/** Tags to filter skills by (e.g. ['velo', 'cms']) */
 	skillsTags?: string[];
+	/** Append the management recipes list (every recipe by area, each a link to its article) to the end of WixREADME, for every client. Default true; false leaves it out, and the README then points at the wix-manage skill and the public list only. */
+	readmeRecipesIndexEnabled?: boolean;
 	/** Enable dynamic context fetch */
 	dynamicContextEnabled?: boolean;
 	/** Enable partner context section in dynamic context output */
 	partnerContextEnabled?: boolean;
-	/** Whether the client is a CLI environment (e.g. Claude Code) where users can run terminal commands.
-	 *  Accepts a boolean or a function for lazy evaluation (useful when client name is only known after MCP init). */
+	/** GetSiteContext renders the site's companion app. Off by default: only Aria (via the toolkit) needs it. */
+	includeCompanionApp?: boolean;
+	/** @deprecated Only CreateWixBusinessGuide read it, and that tool was removed; ignored. */
 	cliEnabled?: boolean | (() => boolean);
 	/** Use the new platformized semantic search API (POST /v1/docs/search) instead of the legacy GET endpoint */
 	usePlatformizedSearch?: boolean;
 	/** Use the platformized menu browse API (POST /v1/docs/menu/browse) instead of scraping the legacy get-menu-content markdown. Falls back to legacy on transport errors. */
 	usePlatformizedBrowse?: boolean;
+	/**
+	 * The Mintlify docs site (see ./mintlify-docs.ts). Off by default.
+	 * `'mintlify'`: REST and SDK search read the Mintlify KBs, and articles are
+	 * read from Mintlify's `.md`. `'mintlify-links'`: search reads today's KBs and
+	 * resolves the links in tool output to the Mintlify site.
+	 */
+	docsSite?: string;
 }
 export interface ToolHintsConfig {
 	readOnlyHint?: boolean;
@@ -256,8 +270,8 @@ export interface WixToolkitApiConfig {
 	toolHints?: Record<string, ToolHintsConfig>;
 	/**
 	 * Max response size in chars before truncation. Applies to CallWixSiteAPI/
-	 * ListWixSites/ManageWixSite (default: 50,000) and to ExecuteWixAPI/
-	 * SearchWixAPISpec (default: 24,000). Always clamped to a hard ceiling
+	 * ListWixSites/ManageWixSite (default: 50,000), ExecuteWixAPI (default:
+	 * 100,000) and SearchWixAPISpec (default: 64,000). Always clamped to a hard ceiling
 	 * regardless of what's requested here — see MAX_ALLOWED_RESPONSE_CHARS.
 	 */
 	maxResponseSize?: number;
@@ -414,13 +428,6 @@ export declare const SYSTEM_REMINDER: string;
  */
 export declare const defaultToolDescriptions: Record<string, string>;
 export declare const executeCodeModeToolDescriptions: Record<string, string>;
-/**
- * Default readme docs - content for WixREADME tool response.
- * Assumes both ExecuteWixAPI and SearchWixAPISpec are available (execute-and-search mode).
- *
- * Joined rather than interpolated into one `dedent` — `dedent` reads indentation from the literal
- * parts only, so a multi-line interpolation gets flattened.
- */
 export declare const defaultReadmeDocs: ReadmeDocConfig$1[];
 /**
  * Merge base config with overrides

package/build/dts/toolkit-entry.d.ts

@@ -107,7 +107,8 @@ declare const VALID_DOCS_TOOLS: readonly [
 	"VELO",
 	"BUSINESS_SOLUTIONS",
 	"CLI",
-	"OVERVIEW"
+	"OVERVIEW",
+	"HELP_CENTER"
 ];
 export type DocsTool = (typeof VALID_DOCS_TOOLS)[number];
 /**
@@ -126,9 +127,12 @@ export interface ReadmeDocConfig {
 }
 export interface DocsToolsOptions {
 	getToKnowWixEnabled?: boolean;
+	/** @deprecated CreateWixBusinessGuide was removed (StartHeadlessBuild replaces its headless route); ignored. */
 	createWixBusinessGuideEnabled?: boolean;
 	/** StartDeployWebsite (publish ready-made site files) — an account-owner flow; off for visitor servers. */
 	startDeployWebsiteEnabled?: boolean;
+	/** StartHeadlessBuild (build a new site in code) — an account-owner flow; off for visitor servers. */
+	startHeadlessBuildEnabled?: boolean;
 	disableTools?: string[];
 	/** Custom descriptions for tools, keyed by tool name */
 	toolDescriptions?: Record<string, string>;
@@ -148,17 +152,27 @@ export interface DocsToolsOptions {
 	commitHash?: string;
 	/** Tags to filter skills by (e.g. ['velo', 'cms']) */
 	skillsTags?: string[];
+	/** Append the management recipes list (every recipe by area, each a link to its article) to the end of WixREADME, for every client. Default true; false leaves it out, and the README then points at the wix-manage skill and the public list only. */
+	readmeRecipesIndexEnabled?: boolean;
 	/** Enable dynamic context fetch */
 	dynamicContextEnabled?: boolean;
 	/** Enable partner context section in dynamic context output */
 	partnerContextEnabled?: boolean;
-	/** Whether the client is a CLI environment (e.g. Claude Code) where users can run terminal commands.
-	 *  Accepts a boolean or a function for lazy evaluation (useful when client name is only known after MCP init). */
+	/** GetSiteContext renders the site's companion app. Off by default: only Aria (via the toolkit) needs it. */
+	includeCompanionApp?: boolean;
+	/** @deprecated Only CreateWixBusinessGuide read it, and that tool was removed; ignored. */
 	cliEnabled?: boolean | (() => boolean);
 	/** Use the new platformized semantic search API (POST /v1/docs/search) instead of the legacy GET endpoint */
 	usePlatformizedSearch?: boolean;
 	/** Use the platformized menu browse API (POST /v1/docs/menu/browse) instead of scraping the legacy get-menu-content markdown. Falls back to legacy on transport errors. */
 	usePlatformizedBrowse?: boolean;
+	/**
+	 * The Mintlify docs site (see ./mintlify-docs.ts). Off by default.
+	 * `'mintlify'`: REST and SDK search read the Mintlify KBs, and articles are
+	 * read from Mintlify's `.md`. `'mintlify-links'`: search reads today's KBs and
+	 * resolves the links in tool output to the Mintlify site.
+	 */
+	docsSite?: string;
 }
 export interface ToolHintsConfig {
 	readOnlyHint?: boolean;
@@ -256,8 +270,8 @@ export interface WixToolkitApiConfig {
 	toolHints?: Record<string, ToolHintsConfig>;
 	/**
 	 * Max response size in chars before truncation. Applies to CallWixSiteAPI/
-	 * ListWixSites/ManageWixSite (default: 50,000) and to ExecuteWixAPI/
-	 * SearchWixAPISpec (default: 24,000). Always clamped to a hard ceiling
+	 * ListWixSites/ManageWixSite (default: 50,000), ExecuteWixAPI (default:
+	 * 100,000) and SearchWixAPISpec (default: 64,000). Always clamped to a hard ceiling
 	 * regardless of what's requested here — see MAX_ALLOWED_RESPONSE_CHARS.
 	 */
 	maxResponseSize?: number;
@@ -414,13 +428,6 @@ export declare const SYSTEM_REMINDER: string;
  */
 export declare const defaultToolDescriptions: Record<string, string>;
 export declare const executeCodeModeToolDescriptions: Record<string, string>;
-/**
- * Default readme docs - content for WixREADME tool response.
- * Assumes both ExecuteWixAPI and SearchWixAPISpec are available (execute-and-search mode).
- *
- * Joined rather than interpolated into one `dedent` — `dedent` reads indentation from the literal
- * parts only, so a multi-line interpolation gets flattened.
- */
 export declare const defaultReadmeDocs: ReadmeDocConfig$1[];
 /**
  * Merge base config with overrides

package/build/dts/toolkit.d.ts

@@ -107,8 +107,8 @@ export interface WixToolkitApiConfig {
     toolHints?: Record<string, ToolHintsConfig>;
     /**
      * Max response size in chars before truncation. Applies to CallWixSiteAPI/
-     * ListWixSites/ManageWixSite (default: 50,000) and to ExecuteWixAPI/
-     * SearchWixAPISpec (default: 24,000). Always clamped to a hard ceiling
+     * ListWixSites/ManageWixSite (default: 50,000), ExecuteWixAPI (default:
+     * 100,000) and SearchWixAPISpec (default: 64,000). Always clamped to a hard ceiling
      * regardless of what's requested here — see MAX_ALLOWED_RESPONSE_CHARS.
      */
     maxResponseSize?: number;