@wix/mcp 1.0.7 → 1.0.8

package/build/index.d.ts

@@ -4,3 +4,4 @@ export { addApiCallTool } from './api-call/index.js';
 export { handleWixAPIResponse } from './tool-utils.js';
 export { addDocsResources } from './resources/docs.js';
 export { addSupportTool } from './support/index.js';
+export { McpAuthenticationStrategy, McpHeaders } from './auth/index.js';

package/build/index.js

@@ -1,201 +1,6 @@
-
-// Shim require if needed.
-import module from 'module';
-if (typeof globalThis.require === "undefined") {
-  globalThis.require = module.createRequire(import.meta.url);
-}
-
-import {
-  VALID_DOCS_TOOLS,
-  WixMcpServer,
-  addDocsResources,
-  addDocsTools,
-  handleWixAPIResponse,
-  logger
-} from "./chunk-QGIZNLF4.js";
-
-// src/api-call/index.ts
-import { z } from "zod";
-function addApiCallTool(server, getSiteAccessToken, getAccountAccessToken) {
-  server.tool(
-    "CallWixSiteAPI",
-    [
-      "Call Wix apis on a business or site. Use this to create, read, update, and delete data and other Wix entities in your Wix site,",
-      `You should ALWAYS check the rest docs - "SearchWixRESTDocumentation" for the specific API you want to call, don't just call it without knowing what it does, CHECK THE DOCS`,
-      "Error Handling:",
-      'If the error is related to missing installed app or "WDE0110: Wix Code not enabled", you should install the missing app by using ReadFullDocsArticle tool to fetch the article - https://dev.wix.com/docs/kb-only/MCP_REST_RECIPES_KB_ID/TRAIN_wix.devcenter.apps.installer.v1.AppsInstallerService.InstallApp',
-      "**Note:** there is no need to check if an app is installed/ Wix Code enabled in advance, just call the API and handle the error if it occurs, the API error message will state it clearly.",
-      "For any other error, use your default error handling mechanism"
-    ].join("\n"),
-    {
-      siteId: z.string().describe("The id of the site selected using site selection tool"),
-      url: z.string().describe(
-        "The url of the api to call - ALWAYS get the information from the Wix REST docs or from the conversation context, the URL MUST BE ABSOLUTE URL"
-      ),
-      method: z.string().describe(
-        "The HTTP method to use for the API call (e.g. GET, POST, PUT, DELETE)"
-      ),
-      body: z.string().optional().describe(
-        "A string representing of a valid JSON object to describe the body of the request"
-      )
-    },
-    async ({ url, body, method, siteId }) => {
-      logger.log(
-        `Calling Wix Site API: ${siteId} ${url}, body: ${JSON.stringify(body)}`
-      );
-      const authorization = await getSiteAccessToken(siteId);
-      try {
-        const response = await fetch(url, {
-          method,
-          headers: {
-            Authorization: authorization,
-            ...body ? { "Content-Type": "application/json" } : {}
-          },
-          body: method === "GET" ? void 0 : body
-        });
-        const responseData = await handleWixAPIResponse(response);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Wix Site API call successful: ${JSON.stringify(responseData)}`
-            }
-          ]
-        };
-      } catch (error) {
-        logger.error(`Failed to call Wix Site API: ${error}`);
-        throw new Error(`Failed to call Wix Site API: ${error}`);
-      }
-    }
-  );
-  server.tool(
-    "ListWixSites",
-    "List Wix sites for the current user",
-    async () => {
-      const sitesRes = await fetch(
-        "https://www.wixapis.com/site-list/v2/sites/query",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/plain, */*",
-            Authorization: await getAccountAccessToken()
-          },
-          body: JSON.stringify({
-            query: {
-              cursorPaging: { limit: 50 }
-            }
-          })
-        }
-      );
-      const result = await sitesRes.json().then(
-        ({ sites }) => sites?.map(({ id, displayName }) => ({
-          id,
-          name: displayName
-        })) ?? []
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          },
-          {
-            type: "text",
-            text: "if there is more than one site returned, the user should pick one from a list, list the sites (only name) for the user and ask them to pick one"
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "ManageWixSite",
-    `Use account level API in order to create a site, update a site and publish site.
-    ALWAYS use "SearchWixRESTDocumentation" to search for the API you should invoke, NEVER GUESS THE SITE API URL
-    You should ALWAYS check the rest docs - "SearchWixRESTDocumentation" for the specific API you want to call, don't just call it without knowing what it does, CHECK THE DOCS`,
-    {
-      url: z.string().describe(
-        "The url of the api to call - ALWAYS get the information from the Wix REST docs DONT GUESS IT, the URL MUST BE ABSOLUTE URL"
-      ),
-      method: z.string().describe(
-        "The HTTP method to use for the API call (e.g. GET, POST, PUT, DELETE)"
-      ),
-      body: z.string().optional().describe(
-        "A string representing of a valid JSON object to describe the body of the request"
-      )
-    },
-    async ({ url, body, method }) => {
-      logger.log(
-        `Calling Wix Account level API: ${url}, body: ${JSON.stringify(body)}`
-      );
-      const authorization = await getAccountAccessToken();
-      try {
-        const response = await fetch(url, {
-          method,
-          headers: {
-            Authorization: authorization,
-            ...body ? { "Content-Type": "application/json" } : {}
-          },
-          body: method === "GET" ? void 0 : body
-        });
-        const responseData = await handleWixAPIResponse(response);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Wix Account API call successful: ${JSON.stringify(responseData)}`
-            }
-          ]
-        };
-      } catch (error) {
-        logger.error(`Failed to call Wix Account API: ${error}`);
-        throw new Error(`Failed to call Wix Account API: ${error}`);
-      }
-    }
-  );
-}
-
-// src/support/index.ts
-import { z as z2 } from "zod";
-function addSupportTool(server) {
-  server.tool(
-    "SupportAndFeedback",
-    [
-      "If the user would like to provide Wix with some feedback (good or bad), about the tools in Wix MCP,",
-      "for example they used the tools provided, and they reflected satisfaction or dissatisfaction with the tools.",
-      "Also, if you encounter too many errors tyring to call the Wix API, you can also suggest the user to provide feedback to Wix using this tool.",
-      "**IMPORTANT NOTE**",
-      "This tool is not sending the message, but formats it in order to another tool to actually send it"
-    ].join("\n"),
-    {
-      requestId: z2.string().optional().describe(
-        "request id if returned from the server in a failed API call to Wix"
-      ),
-      message: z2.string().describe("The message to send to Wix")
-    },
-    async ({ requestId, message }) => {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${message} ${requestId ? `request id: ${requestId}` : ""}`
-          },
-          {
-            type: "text",
-            text: "You should present the user with the formatted message above and ask if they would like to send it to Wix.If the user confirms, you can get the details about send feedback API from the article `https://dev.wix.com/docs/kb-only/MCP_REST_RECIPES_KB_ID/TRAIN_send_mcp_feedback_to_wix_from_user`.You can use the `ReadFullDocsArticle` tool to fetch the article and get the details about the API call.Once you have the details, you can use the `ManageWixSite` (if site id is in context) or `CallWixSiteAPI` (if site id is not in context) tool to call the API and send the feedback to Wix."
-          }
-        ]
-      };
-    }
-  );
-}
-export {
-  VALID_DOCS_TOOLS,
-  WixMcpServer,
-  addApiCallTool,
-  addDocsResources,
-  addDocsTools,
-  addSupportTool,
-  handleWixAPIResponse
-};
-//# sourceMappingURL=index.js.map
+export { WixMcpServer } from './wix-mcp-server.js';
+export { addDocsTools, VALID_DOCS_TOOLS } from './docs/docs.js';
+export { addApiCallTool } from './api-call/index.js';
+export { handleWixAPIResponse } from './tool-utils.js';
+export { addDocsResources } from './resources/docs.js';
+export { addSupportTool } from './support/index.js';

package/build/infra/bi-logger.d.ts

@@ -0,0 +1,2 @@
+import type { BiEvent, BiLogger } from '@wix/wix-bi-logger-client';
+export declare function createBiLogger(defaultFields?: BiEvent): BiLogger;

package/build/infra/bi-logger.js

@@ -0,0 +1,10 @@
+import { StandaloneNodeLogger } from '@wix/standalone-node-bi-logger';
+export function createBiLogger(defaultFields) {
+    return new StandaloneNodeLogger()
+        .factory({})
+        .updateDefaults({
+        localTime: () => Date.now(),
+        ...defaultFields
+    })
+        .logger();
+}

package/build/infra/environment.d.ts

@@ -0,0 +1,9 @@
+export declare enum ENV {
+    DEV = "DEV",
+    TEST = "TEST",
+    LOCAL = "LOCAL",
+    REMOTE = "REMOTE",
+    PICASSO = "PICASSO"
+}
+export declare const DEV_ENVIRONMENTS: ENV[];
+export declare function getEnvironment(nodeEnv?: string): ENV;

package/build/infra/environment.js

@@ -0,0 +1,27 @@
+export var ENV;
+(function (ENV) {
+    ENV["DEV"] = "DEV";
+    ENV["TEST"] = "TEST";
+    ENV["LOCAL"] = "LOCAL";
+    ENV["REMOTE"] = "REMOTE";
+    ENV["PICASSO"] = "PICASSO";
+})(ENV || (ENV = {}));
+const DEFAULT_ENV = ENV.LOCAL;
+export const DEV_ENVIRONMENTS = [ENV.DEV, ENV.TEST];
+export function getEnvironment(nodeEnv) {
+    const env = nodeEnv || process.env.NODE_ENV;
+    switch (env?.toUpperCase()) {
+        case 'DEV':
+            return ENV.DEV;
+        case 'TEST':
+            return ENV.TEST;
+        case 'LOCAL':
+            return ENV.LOCAL;
+        case 'REMOTE':
+            return ENV.REMOTE;
+        case 'PICASSO':
+            return ENV.PICASSO;
+        default:
+            return DEFAULT_ENV;
+    }
+}

package/build/infra/logger.js

@@ -0,0 +1,61 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { homedir } from 'os';
+const createNullLogger = () => {
+    return {
+        log: () => { },
+        error: () => { }
+    };
+};
+const createStdErrLogger = () => {
+    return {
+        log: (data) => {
+            console.error(data);
+        },
+        error: (data) => {
+            console.error(data);
+        }
+    };
+};
+const createMcpServerLogger = (server) => {
+    return {
+        log: (data) => {
+            server.server.sendLoggingMessage({ level: 'info', data });
+        },
+        error: (data) => {
+            server.server.sendLoggingMessage({ level: 'error', data });
+        }
+    };
+};
+const createFileLogger = () => {
+    const filePath = path.join(homedir(), 'wix-mcp-log.txt');
+    const date = new Date()
+        .toLocaleString('en-US', { timeZone: 'Asia/Jerusalem' })
+        .replace(/,/g, '');
+    return {
+        log: (...data) => {
+            const message = `[info] ${date} - ${data.join(' ')}`;
+            fs.appendFile(filePath, `${message}\n`);
+        },
+        error: (...data) => {
+            const message = `[error] ${date} - ${data.join(' ')}`;
+            fs.appendFile(filePath, `${message}\n`);
+        }
+    };
+};
+export const logger = createNullLogger();
+export const attachMcpServerLogger = (server) => {
+    const mcpLogger = createMcpServerLogger(server);
+    logger.log = mcpLogger.log;
+    logger.error = mcpLogger.error;
+};
+export const attachStdErrLogger = () => {
+    const stdErrLogger = createStdErrLogger();
+    logger.log = stdErrLogger.log;
+    logger.error = stdErrLogger.error;
+};
+export const attachFileLogger = () => {
+    const fileLogger = createFileLogger();
+    logger.log = fileLogger.log;
+    logger.error = fileLogger.error;
+};

package/build/infra/panorama.d.ts

@@ -0,0 +1,7 @@
+import type { ENV } from './environment.js';
+export declare const createPanoramaClient: (opts: {
+    environment: ENV;
+    sessionId: string;
+    componentId: string;
+    uuid?: string;
+}) => import("@wix/panorama-client-node").PanoramaClient;

package/build/infra/panorama.js

@@ -0,0 +1,35 @@
+// import { createRequire } from 'module';
+import { createGlobalConfig, panoramaClientFactory, PanoramaPlatform } from '@wix/panorama-client-node';
+// const require = createRequire(import.meta.url);
+// const packageJson = require('../package.json');
+// TODO: use real package.json
+// I temporarily disabled this because it's not working in the remote server
+const packageJson = {
+    version: '1.0.0'
+};
+export const createPanoramaClient = (opts) => {
+    const globalPanoramaConfig = createGlobalConfig();
+    globalPanoramaConfig.setSessionId(opts.sessionId);
+    const panoramaFactory = panoramaClientFactory({
+        reporterOptions: {
+            silent: true
+        },
+        baseParams: {
+            uuid: opts.uuid,
+            componentId: opts.componentId,
+            platform: PanoramaPlatform.Standalone,
+            fullArtifactId: 'com.wixpress.spartans.wix-mcp',
+            artifactVersion: packageJson.version
+        },
+        data: {
+            environment: opts.environment,
+            runtime: {
+                packageVersion: packageJson.version,
+                versions: process.versions,
+                platform: process.platform,
+                arch: process.arch
+            }
+        }
+    }).withGlobalConfig(globalPanoramaConfig);
+    return panoramaFactory.client();
+};

package/build/infra/sentry.d.ts

@@ -0,0 +1 @@
+export {};

package/build/infra/sentry.js

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+Sentry.init({
+    dsn: 'https://583c5af58c664fd1977d638a693b0ada@sentry-next.wixpress.com/20924',
+    tracesSampleRate: 1.0,
+    initialScope: {
+        tags: {
+            fullArtifactId: 'com.wixpress.spartans.wix-mcp'
+        }
+    }
+});

package/build/interactive-command-tools/eventually.js

@@ -0,0 +1,15 @@
+import waitForExpect from 'wait-for-expect';
+const defaultOptions = {
+    timeout: 10000,
+    interval: 200
+};
+export default async function eventually(expectation, options) {
+    return new Promise((resolve, reject) => {
+        waitForExpect
+            .default(async () => {
+            const ret = await expectation();
+            resolve(ret);
+        }, options?.timeout ?? defaultOptions.timeout, options?.interval ?? defaultOptions.interval)
+            .catch((error) => reject(error));
+    });
+}

package/build/interactive-command-tools/handleStdout.js

@@ -0,0 +1,75 @@
+import stripAnsi from 'strip-ansi';
+import eventually from './eventually.js';
+import { logger } from '../infra/logger.js';
+export function handleStdout(stdout) {
+    let checkStartIndex = 0;
+    const lines = [];
+    logger.log(`handleStdout: stdout: ${stdout}`);
+    stdout.on('data', (chunk) => {
+        logger.log(`handleStdout: chunk: ${chunk}`);
+        // log(`create-cli: chunk: ${chunk}`);
+        lines.push(...stripAnsi(chunk.toString()).split('\n'));
+    });
+    return {
+        async waitForText(match, { timeout = 2 * 60 * 1000 } = {}) {
+            return eventually(() => {
+                const matchedIndex = lines.findIndex((line, index) => {
+                    if (index < checkStartIndex) {
+                        return false;
+                    }
+                    if (typeof match === 'string') {
+                        return line.includes(match);
+                    }
+                    return line.match(match);
+                });
+                checkStartIndex = matchedIndex >= 0 ? matchedIndex + 1 : lines.length;
+                if (matchedIndex !== -1) {
+                    return lines[matchedIndex];
+                }
+                const message = `Could not match text in output: ${match}`;
+                throw new Error(message);
+            }, { timeout });
+        },
+        async waitForAndCallback(matchesAndCallbacks, { timeout = 2 * 60 * 1000 } = {}) {
+            let stopResolve;
+            const stopPromise = new Promise((resolve) => {
+                stopResolve = resolve;
+            });
+            // Keep track of matches we've already processed
+            const processedMatches = new Set();
+            const waitPromise = eventually(() => {
+                //log(`create-cli: waiting for ${matchesAndCallbacks.length - processedMatches.size} matches`);
+                for (const { match, callback } of matchesAndCallbacks) {
+                    // Skip if we've already processed this match
+                    if (processedMatches.has(match)) {
+                        continue;
+                    }
+                    if (lines.some((line) => line.includes(match))) {
+                        logger.log(`create-cli: found match ${match}`);
+                        // Add to processed matches so we don't match it again
+                        processedMatches.add(match);
+                        callback(() => {
+                            logger.log(`create-cli: stopping match loop`);
+                            stopResolve();
+                        });
+                    }
+                    else {
+                        // log(`create-cli: waiting for ${match}`);
+                    }
+                }
+                // If we've processed all matches, we're done
+                if (processedMatches.size === matchesAndCallbacks.length) {
+                    return true;
+                }
+                throw new Error(`Could not find any of the remaining matches: ${matchesAndCallbacks
+                    .filter((m) => !processedMatches.has(m.match))
+                    .map((m) => m.match)
+                    .join(', ')}`);
+            }, { timeout });
+            return Promise.race([waitPromise, stopPromise]);
+        },
+        async getOutput() {
+            return lines.join('\n');
+        }
+    };
+}

package/build/interactive-command-tools/interactive-command-utils.js

@@ -0,0 +1,75 @@
+import { handleStdout } from './handleStdout.js';
+import { logger } from '../infra/logger.js';
+export const ENTER = '\r';
+const DOWN = '\u001b[B';
+export const mockInteractiveGenerateCommandTool = async ({ extensionType, stdin, stdout }) => {
+    try {
+        logger.log('RunWixCliCommand: handle stdout');
+        const stdoutHandler = handleStdout(stdout);
+        logger.log('RunWixCliCommand: waiting for text');
+        await stdoutHandler.waitForText('What kind of extension would you like to generate?');
+        // Enter the extension type
+        if (extensionType === 'DASHBOARD_PAGE') {
+            // No need to press enter
+        }
+        else if (extensionType === 'BACKEND_EVENT') {
+            logger.log('RunWixCliCommand: writing DOWN 9 times');
+            for (let i = 0; i < 9; i++) {
+                stdin.write(DOWN);
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+        }
+        logger.log('RunWixCliCommand: writing ENTER 1');
+        stdin.write(ENTER);
+        // Wait for next step
+        if (extensionType === 'DASHBOARD_PAGE') {
+            await stdoutHandler.waitForText('Page title');
+            logger.log('RunWixCliCommand: writing ENTER 2');
+            stdin.write(ENTER);
+            await stdoutHandler.waitForText('Enter the route for the new page');
+            logger.log('RunWixCliCommand: writing ENTER 3');
+            stdin.write(ENTER);
+        }
+        else if (extensionType === 'BACKEND_EVENT') {
+            await stdoutHandler.waitForText('Event folder');
+            logger.log('RunWixCliCommand: writing ENTER 2');
+            stdin.write(ENTER);
+            logger.log('RunWixCliCommand: waiting for text');
+            // Check if the text is "Would you like to install dependencies now?", if dependencies are already installed, it will not be printed
+            try {
+                await stdoutHandler.waitForText('Would you like to install dependencies now?', { timeout: 1000 });
+                logger.log('RunWixCliCommand: writing ENTER 3');
+                stdin.write(ENTER);
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes('Could not match text in output')) {
+                    logger.log('RunWixCliCommand: dependencies are already installed, skipping install');
+                    logger.log(await stdoutHandler.getOutput());
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        logger.log('RunWixCliCommand: waiting for success message');
+        try {
+            await stdoutHandler.waitForText('Successfully', { timeout: 1000 });
+            logger.log('RunWixCliCommand: success message found');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('Could not match text in output')) {
+                logger.log('RunWixCliCommand: success message not found, skipping'); // just skip and try to continue by returning the output
+            }
+            else {
+                throw error;
+            }
+        }
+        return stdoutHandler.getOutput();
+    }
+    catch (error) {
+        logger.error('RunWixCliCommand: error', error);
+        throw error;
+    }
+};

package/build/resources/docs.js

@@ -0,0 +1,45 @@
+import { logger } from '../infra/logger.js';
+const getPortalIndex = async (portalName) => {
+    const response = await fetch(`https://dev.wix.com/digor/api/portal-index?portalName=${portalName}`);
+    const data = await response.json();
+    return data;
+};
+const addPortalResources = async (server, portalName) => {
+    // get portal index:
+    const portalIndexResponse = await getPortalIndex(portalName);
+    logger.log(`portalIndexResponse for ${portalName}`, JSON.stringify(portalIndexResponse, null, 2));
+    // for each portalIndex entry, add a resource to the server:
+    for (const entry of portalIndexResponse.portalIndex) {
+        logger.log(`entry ${JSON.stringify(entry, null, 2)}`);
+        const name = entry.url;
+        const uri = entry.url.replace('https://dev.wix.com/docs/', 'wix-docs://');
+        logger.log(`adding resource ${name} ${uri}`);
+        server.resource(name, uri, async (uri) => {
+            logger.log(`fetching resource ${uri}`);
+            const docsURL = uri
+                .toString()
+                .replace('wix-docs://', 'https://dev.wix.com/docs/');
+            const response = await fetch(`https://dev.wix.com/digor/api/get-article-content?articleUrl=${encodeURIComponent(docsURL)}`);
+            const data = await response.json();
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: data.articleContent || 'No content found'
+                    }
+                ]
+            };
+        });
+    }
+};
+export const addDocsResources = async (server, portals) => {
+    for (const portal of portals) {
+        try {
+            logger.log(`Processing portal: ${portal}`);
+            await addPortalResources(server, portal);
+        }
+        catch (error) {
+            logger.error(`Error processing portal ${portal}:`, error);
+        }
+    }
+};

package/build/support/index.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export function addSupportTool(server) {
+    server.tool('SupportAndFeedback', [
+        'If the user would like to provide Wix with some feedback (good or bad), about the tools in Wix MCP,',
+        'for example they used the tools provided, and they reflected satisfaction or dissatisfaction with the tools.',
+        'Also, if you encounter too many errors tyring to call the Wix API, you can also suggest the user to provide feedback to Wix using this tool.',
+        '**IMPORTANT NOTE**',
+        'This tool is not sending the message, but formats it in order to another tool to actually send it'
+    ].join('\n'), {
+        requestId: z
+            .string()
+            .optional()
+            .describe('request id if returned from the server in a failed API call to Wix'),
+        message: z.string().describe('The message to send to Wix')
+    }, async ({ requestId, message }) => {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${message} ${requestId ? `request id: ${requestId}` : ''}`
+                },
+                {
+                    type: 'text',
+                    text: 'You should present the user with the formatted message above and ask if they would like to send it to Wix.' +
+                        'If the user confirms, you can get the details about send feedback API from the article `https://dev.wix.com/docs/kb-only/MCP_REST_RECIPES_KB_ID/TRAIN_send_mcp_feedback_to_wix_from_user`.' +
+                        'You can use the `ReadFullDocsArticle` tool to fetch the article and get the details about the API call.' +
+                        'Once you have the details, you can use the `ManageWixSite` (if site id is in context) or `CallWixSiteAPI` (if site id is not in context) tool to call the API and send the feedback to Wix.'
+                }
+            ]
+        };
+    });
+}

package/build/tool-utils.d.ts

@@ -1 +1,2 @@
-export declare const handleWixAPIResponse: <T = any>(response: Response) => Promise<T>;
+import type { HttpResponse } from '@wix/http-client';
+export declare const handleWixAPIResponse: <T = any>(response: HttpResponse<any>) => Promise<T>;

package/build/tool-utils.js

@@ -0,0 +1,30 @@
+const safeParseJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+export const handleWixAPIResponse = async (response) => {
+    const responseData = typeof response.data === 'string'
+        ? safeParseJSON(response.data)
+        : response.data;
+    if (!response.status.toString().startsWith('2')) {
+        const requestId = response.headers.get('x-wix-request-id');
+        const errorDetails = typeof responseData === 'object'
+            ? JSON.stringify(responseData)
+            : responseData;
+        throw new Error([
+            `Failed to call Wix API: ${response.status} ${response.statusText}.`,
+            requestId ? `request id: ${requestId}` : '',
+            // Wix 404 for API does not exist is huge (generic 404 page) and loaded to the context
+            response.status === 404 && errorDetails.includes('<html')
+                ? 'Not found'
+                : errorDetails
+        ]
+            .filter((str) => !!str)
+            .join('\n'));
+    }
+    return responseData;
+};