@wix/mcp 1.0.81 → 1.0.83

package/build/esm/index.js

@@ -29818,6 +29818,11 @@ var WixMcpServer = class extends McpServer {
   isMcpAppsInMcpEnabled() {
     return this.mcpAppsInMcpEnabled;
   }
+  /** Microsoft 365 Copilot ("sydney" at runtime) or Copilot Cowork ("copilot"). */
+  isMicrosoftCopilotClient() {
+    const clientName = this.getClientName?.()?.toLowerCase() ?? "";
+    return clientName.includes("sydney") || clientName.includes("copilot");
+  }
   shouldRenderMcpApps() {
     const clientName = this.getClientName?.()?.toLowerCase();
     const isOpenAi = clientName?.includes("openai") ?? false;
@@ -30942,6 +30947,8 @@ var SITE_CREATION_COPY = {
 var SITE_GUIDANCE = dedent_default`
   A new-site request has two things to settle: what the site is for, and how to build it. The how is AI generation vs. starting from a template, so naming templates, a template id or Wix Studio (Wix Studio is also the template side) already settles it.
 
+  One case skips all of this: the user ALREADY HAS the finished site as files — hand-written HTML/CSS/JS, a zip, or the export of an AI builder. There is nothing to build, so don't offer AI or templates and don't call any site-creation tool. Send them to https://www.wix.com/headless/drop?utm_campaign=mcp — they drag the files in and get a live Wix-hosted site. Give that URL exactly as written, keeping the utm_campaign=mcp parameter.
+
   Settle what the site is for first: its purpose, topic, business type, audience, or main visitor action. Naming a method is not a description of the site, and neither is the business or industry on its own.
   If you can't tell yet, ask the preferred question below and nothing else — one question, no creation-method question in the same reply, and no internal tool names.
   Once the purpose is clear, unless the user already named a method, ${SITE_CREATION_COPY.unstatedMethod.nonWidget}. A method they named is settled — never re-open it. Never default to AI or to templates, and never ask the user to choose between Harmony and Wix Studio; infer that from their words.
@@ -31274,7 +31281,8 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     After calling, you MUST speak the message provided in the tool result to the user as your reply — do not stay silent and do not replace it with a one-line pointer to the widget. Write out ALL of it, word for word: its opening line (the "Ready to set up your … site?" question INCLUDING "Choose your path in the widget above:"), BOTH of its option bullets, and its "Next up:" line, each on its own line and in that order. Do not summarize, shorten, drop any line, invent your own opener, rename the options, or add an intro or outro.
   `,
     "import-claude-design-from-url": dedent_default`
-    Import a design into Wix from a publicly fetchable URL. The file is a self-contained HTML bundle with all images, fonts, and styles inlined. Creates a live Wix-hosted site and returns its URL.
+    Import a design created in Claude's design tool into Wix. Takes the signed claudeusercontent.com URL Claude Design produces for its self-contained HTML bundle (all images, fonts, and styles inlined); any other host is rejected. Creates a live Wix-hosted site and returns its URL.
+    NOT for site files the user provides themselves (their own HTML/CSS/JS, a zip, another builder's export) — for those, don't call this tool: send the user to https://www.wix.com/headless/drop?utm_campaign=mcp, where they upload the files and get a live hosted site. Give that URL exactly as written, keeping the utm_campaign=mcp parameter.
   `,
     RunWixCliCommand: dedent_default`
     Executes Wix CLI commands for Wix app development and management.
@@ -31671,10 +31679,37 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
 
     Call this when the user provides a specific template by \`metaSiteId\` or \`templateId\`. Use this only when the user gives a valid \`metaSiteId\` or \`templateId\` directly. To browse or choose a template first, call \`SearchSiteTemplates\`.
 
+  `,
+    SearchWixGraphQLOperations: dedent_default`
+    Discover Wix GraphQL operations by intent (ranked keyword search over the root fields). Wix exposes ONE GraphQL schema over all Wix public APIs (Developer Preview) at POST https://www.wixapis.com/graphql/alpha: about 100 query roots and 580 mutation roots named <app><Service><Version><Verb/Entity>, e.g. \`storesProductsV3V3Products\`, \`crmContactsV4Contacts\`, \`crmContactsV4CreateContact\`, \`ecomOrdersV1SearchOrders\`.
+
+    GraphQL flow (3 steps, keep to it): SearchWixGraphQLOperations (find the operation) -> InspectWixGraphQLSchema (read its exact input and return types) -> ExecuteWixGraphQL (run it). Never write an operation or field name you did not see in one of these results.
+
+    When to prefer GraphQL over the REST tools:
+    - Reading several related entities in ONE round-trip: related entities are resolved fields (product -> inventoryItems / collections, order -> fulfillments, booking -> contact), and independent root fields (products + contacts + orders) can share one request.
+    - Picking exactly the fields you need, so responses stay small.
+    - Answering "how many / list / show" questions: a query root plus \`pageInfo\` (\`hasNext\`, and \`total\` where the API provides it).
+    Prefer the REST tools when a recipe or code example already gives you the exact REST call, for uploads/media, or when the GraphQL schema has no matching operation.
+
+    Conventions: query roots take \`queryInput\`; list roots (plural names) take \`queryInput: { query: { paging | cursorPaging, filter, sort } }\` and return \`{ items, pageInfo }\`; singular roots take the entity id. \`filter\`/\`sort\` are a JSON scalar in REST filter syntax (e.g. {"info.name.first": {"$eq": "Ada"}}) — pass them as variables. Mutations take \`input\`; a few read operations (search/list) are exposed as mutations, so search kind "all" unless you are sure.
+    Results list \`kind name(arg: InputType): ReturnType\` plus a one-line description; pass the chosen name to InspectWixGraphQLSchema next.
+  `,
+    InspectWixGraphQLSchema: dedent_default`
+    Read the exact Wix GraphQL schema for an operation and its types, as compact SDL with field descriptions. Pass \`operation\` (a root query/mutation name from SearchWixGraphQLOperations) to get its arguments, input type and return type expanded \`depth\` levels (default 2). Types that were referenced but not expanded are listed at the end — pass the ones you need in \`typeNames\` (optionally together with \`operation\`) instead of raising depth for everything.
+    Use it before every ExecuteWixGraphQL call that introduces a new operation or new fields: read the INPUT type before writing a mutation or filter, and the RETURN type before writing the selection set. GraphQL rejects unknown fields and arguments, and every object-typed field needs its own selection set. \`JSON\` scalar fields (filter, sort, free-form data) accept any JSON — pass them as variables. Never guess a type or field name; if a validation error names a field, come back here.
+  `,
+    ExecuteWixGraphQL: dedent_default`
+    Execute a GraphQL query or mutation against the Wix GraphQL API (POST https://www.wixapis.com/graphql/alpha) with the user's credentials. Authentication is injected — never add Authorization or site/account headers.
+    Site targeting: site-level operations (anything that reads or writes inside a site: products, inventory, orders, contacts, bookings, CMS data, blog, members ...) require \`siteId\`; resolve it with GetSiteContext or ListWixSites first. Use \`scope: "account"\` only for account-level operations.
+    Grounding: every root field, argument and selected field must come from SearchWixGraphQLOperations / InspectWixGraphQLSchema results in this conversation — never from memory. If the response says "Cannot query field" or "Unknown argument", re-inspect the schema and fix the name; do not retry with another guess.
+    Compose: put independent reads in one document as several root fields, and use related-entity fields (e.g. \`inventoryItems\`, \`collections\`, \`fulfillments\`) instead of extra round-trips. Select only the fields you need; every object field needs a selection set. Variables: use them for \`JSON\` scalars (filter, sort) and plain scalars (String, Int, ID), declared in the document (e.g. \`query Q($f: JSON) { ... filter: $f ... }\`). Write mutation inputs and any object that contains an enum INLINE as GraphQL literals with enum values unquoted (e.g. \`input: { product: { name: "Mug", productType: PHYSICAL } }\`) — this endpoint fails with 503 when an enum value arrives inside an object-typed variable. For lists page with \`cursorPaging\` or \`paging\` exactly as the input type declares (never the other one), and request \`pageInfo { hasNext total }\`; \`total\` is only populated with offset \`paging\`, so for a cursor-paged list count by walking pages or use a count operation.
+    Results: each root field fails independently — \`errors[].path\` names the failing field and \`errors[].extensions.message\` the cause (e.g. PERMISSION_DENIED); \`data\` still holds the fields that succeeded. Mutations return the created/updated entity — read the IDs from it and do not re-query to verify. Large results are truncated: narrow the selection or page size instead of re-running.
+    Set \`hasMutations: true\` for any document containing a mutation root field.
   `,
     CreateWixBusinessGuide: dedent_default`
     Provides comprehensive documentation for creating a new Wix business (site, app, etc.).
     Call this ONLY when the user explicitly asks for a headless site, a Wix Classic Editor site, or manual/advanced account/API-based site creation — these don't need the site's purpose first. For normal site-creation ${SITE_CREATION_COPY.normalCreationRoute.nonWidget}; for a specific template id, call \`CreateSiteFromTemplate\`.
+    Exception, even when the user says "headless": if they ALREADY HAVE the finished site as files (their own HTML/CSS/JS, a zip, an AI-builder export) and want those files hosted, don't call this tool — send them to https://www.wix.com/headless/drop?utm_campaign=mcp to upload the files and get a live hosted site (give that URL exactly, keeping the utm_campaign=mcp parameter). This guide's CLI flow is for BUILDING a headless frontend, not for hosting ready-made files.
 
     ## What This Tool Contains
 
@@ -31789,7 +31824,8 @@ function mergeConfig(base, overrides) {
     dynamicContextEnabled: overrides.dynamicContextEnabled ?? base.dynamicContextEnabled,
     partnerContextEnabled: overrides.partnerContextEnabled ?? base.partnerContextEnabled,
     usePlatformizedSearch: overrides.usePlatformizedSearch ?? base.usePlatformizedSearch,
-    skillsPrOverrideEnabled: overrides.skillsPrOverrideEnabled ?? base.skillsPrOverrideEnabled
+    skillsPrOverrideEnabled: overrides.skillsPrOverrideEnabled ?? base.skillsPrOverrideEnabled,
+    graphqlEnabled: overrides.graphqlEnabled ?? base.graphqlEnabled
   };
 }
 var defaultConfig = {
@@ -32140,7 +32176,16 @@ var known_apps_default = {
   "1480c568-5cbd-9392-5604-1148f5faffa0": "Promote SEO",
   "ff5d6eb1-65e4-4f9a-8b14-64d34c12cc2e": "Wix Rentals"
 };
-var DYNAMIC_CONTEXT_URL = "https://dev.wix.com/_api/dynamic-context/v1/dynamic-context";
+var DYNAMIC_CONTEXT_PATH = "/_api/dynamic-context/v1/dynamic-context";
+var DYNAMIC_CONTEXT_URL = `https://dev.wix.com${DYNAMIC_CONTEXT_PATH}`;
+var isWixHost = (hostname2) => hostname2 === "wix.com" || hostname2.endsWith(".wix.com");
+var dynamicContextUrl = () => {
+  if (typeof window === "undefined") {
+    return DYNAMIC_CONTEXT_URL;
+  }
+  const hostname2 = window.location?.hostname;
+  return typeof hostname2 === "string" && isWixHost(hostname2) ? DYNAMIC_CONTEXT_PATH : DYNAMIC_CONTEXT_URL;
+};
 var COUNT_SITES_URL = "https://www.wixapis.com/site-list/v2/sites/count";
 var MAX_SITES_FOR_DYNAMIC_CONTEXT = 10;
 var DYNAMIC_CONTEXT_PETRI_OVERRIDE = "shouldReturnDynamicContextInMCP#B";
@@ -32192,7 +32237,7 @@ async function getDynamicContext(auth, httpClient6, filter, options) {
     if (filter?.siteId) body.site_id = filter.siteId;
     else if (filter?.siteName) body.site_name = filter.siteName;
     const dynamicContextPromise = httpClient6.request({
-      url: DYNAMIC_CONTEXT_URL,
+      url: dynamicContextUrl(),
       method: "POST",
       headers: {
         ...accountHeaders,
@@ -32386,6 +32431,27 @@ var paramDescriptions = {
     mimeType: 'MIME type of the image (e.g. "image/jpeg", "image/png", "image/webp"). Required when imageBase64 does not include a data URL prefix.',
     displayName: "Optional display name for the file in Media Manager. If not provided, uses the original filename."
   },
+  SearchWixGraphQLOperations: {
+    query: 'Free-text intent or entity, e.g. "products with inventory", "create contact", "orders", "blog posts", "booking services". Operation names encode app + service + version + verb/entity (e.g. storesProductsV3V3Products, crmContactsV4CreateContact), so a noun plus a verb (query/get/create/update/delete) ranks best. You may also pass an exact operation name.',
+    kind: 'Restrict to "query" (reads), "mutation" (writes \u2014 note a few reads such as search/list calls are exposed as mutations), or "all" (default).',
+    maxResults: "Maximum number of operations to return (default 10, max 50).",
+    reason: "One sentence describing the original user request and why you are looking for a GraphQL operation."
+  },
+  InspectWixGraphQLSchema: {
+    operation: 'Exact root query or mutation name from SearchWixGraphQLOperations (e.g. "crmContactsV4Contacts"). Returns its arguments, input type and return type as compact SDL, expanded `depth` levels.',
+    typeNames: 'Type names to expand, e.g. ones listed as "Not expanded" in a previous result, or a nested input/object/enum type you need before writing the request. Can be combined with `operation`.',
+    depth: "How many levels of referenced types to expand (1-4, default 2). Level 1 is the given types, level 2 the types their fields reference, and so on. Keep it small and expand specific types with typeNames instead of dumping everything.",
+    reason: "One sentence describing the original user request and why you need this part of the GraphQL schema."
+  },
+  ExecuteWixGraphQL: {
+    query: "The GraphQL document (a query or a mutation). Every root field, argument and selected field MUST come from SearchWixGraphQLOperations / InspectWixGraphQLSchema results in this conversation, never from memory. Declare variables for filters, sort and large inputs, e.g. `query Q($f: JSON) { crmContactsV4Contacts(queryInput: { query: { filter: $f, paging: { limit: 50 } } }) { items { id } pageInfo { hasNext } } }`. Object-typed fields need a selection set. You can put several independent root fields in one document.",
+    variables: 'Variables object for the document, as a JSON object (not a string). Use it for JSON-scalar filters/sort (REST filter syntax, e.g. {"info.name.first": {"$eq": "Ada"}}) and plain scalars. Do NOT pass object inputs that contain enum values (product types, statuses, registration types ...) through variables \u2014 write those inline in the document with the enum unquoted; the endpoint returns 503 otherwise.',
+    operationName: "Operation to run when the document defines more than one named operation.",
+    siteId: "The Wix site to run against. Required for site-level operations (anything reading or writing inside a site \u2014 products, orders, contacts, bookings, CMS, blog, members ...). Resolve it with GetSiteContext or ListWixSites; never pass a guessed value.",
+    scope: '"site" (default when siteId is given) runs with a site-scoped credential; "account" runs account-level operations (sites, account settings) and ignores siteId.',
+    hasMutations: "Whether this document creates, updates, deletes or otherwise mutates Wix data. True for any mutation root field (in any operation of the document) even when the intent is inspection; false only for pure queries. This flag alone decides whether a transient server error may be retried, so never mark a document that writes as false.",
+    reason: "One sentence explaining the original user request and why you are running this GraphQL operation to complete it."
+  },
   RunWixCliCommand: {
     appPath: "The full path to the Wix CLI app to run the command on.",
     extensionType: "The type of extension to generate. You MUST provide this for commands that generate extensions.",
@@ -34643,9 +34709,18 @@ var SITE_CREATION_CUSTOM_ACTIONS_GUIDANCE = `2\u20133 specific, high-value setup
 * Events / Weddings / Real Estate: "add event schedules, display listings, and manage RSVP forms"
 * General / Unspecified: "${SITE_CREATION_DEFAULT_ACTIONS}"
 If none of these patterns fit the site, infer 2\u20133 actions that suit what that kind of business would manage on its site.`;
-function buildSiteCreationSelectorMessage(siteType, customActions) {
+function buildSiteCreationSelectorMessage(siteType, customActions, { plain = false } = {}) {
   const type = (siteType ?? "").trim() || "new";
   const actions = (customActions ?? "").trim() || SITE_CREATION_DEFAULT_ACTIONS;
+  const body = `Ready to set up your ${type} site? Choose your path in the widget above:
+
+* **Build with AI** for a custom, tailor-made layout
+* **Pick a template** to start with a pre-designed layout
+
+**Next up:** Once your site is created, you can customize it in Wix or ask me to ${actions}\u2014right here in the chat!`;
+  if (plain) {
+    return body;
+  }
   return `You are the assistant replying to the user \u2014 say this message out loud in chat (do NOT stay silent, and do NOT just point at the widget). Your reply is only complete if it includes ALL of the following, word for word, each on its own line and in this order:
 1. "Ready to set up your ${type} site? Choose your path in the widget above:" \u2014 keep the "Choose your path in the widget above:" part.
 2. "* **Build with AI** for a custom, tailor-made layout"
@@ -34654,12 +34729,7 @@ function buildSiteCreationSelectorMessage(siteType, customActions) {
 
 Copy those four lines as written; do not summarize, shorten, reorder, or reword any of them. Here is the full message to send:
 
-Ready to set up your ${type} site? Choose your path in the widget above:
-
-* **Build with AI** for a custom, tailor-made layout
-* **Pick a template** to start with a pre-designed layout
-
-**Next up:** Once your site is created, you can customize it in Wix or ask me to ${actions}\u2014right here in the chat!`;
+${body}`;
 }
 var OPENAI_WIDGET_MIME_TYPE = "text/html+skybridge";
 var SITE_WIDGET_MCP_CSP = {
@@ -41614,7 +41684,7 @@ function addCreateSiteWidgetTool(server, authStrategy, options) {
           `The prompt to build the site. If not provided, the user will be asked to provide a prompt.`
         ),
         suggestedSiteName: external_exports.string().optional().describe(
-          "Suggested site name to use for the site based on the site prompt."
+          "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."
         )
       },
       _meta: toolDefinitionMeta,
@@ -41771,6 +41841,11 @@ async function buildHarmonySite({
 
 // src/site-widget-tools/suggested-domain-tool/index.ts
 var WIX_APIS_BASE_URL3 = "https://www.wixapis.com";
+var DEFAULT_SITE_NAME = /^my site(\s+\d+)?$/i;
+var NON_LATIN_LETTER = /(?![\p{Script=Latin}])\p{L}/u;
+function isSearchableSiteName(siteName) {
+  return !DEFAULT_SITE_NAME.test(siteName.trim()) && !NON_LATIN_LETTER.test(siteName);
+}
 async function fetchSiteDisplayName(siteAuthorization, siteId) {
   const response = await fetch(
     `${WIX_APIS_BASE_URL3}/site-properties/v4/properties`,
@@ -41795,7 +41870,15 @@ function addSuggestedDomainTool(server, authStrategy) {
     GET_SUGGESTED_DOMAINS_TOOL_NAME,
     {
       title: "Get Suggested Domains",
-      description: 'Suggest available domain names. Provide either a free-text query (e.g. "pancakes business", "modern yoga studio") OR a siteId to auto-suggest based on the site name. At least one of query or siteId is required.',
+      description: dedent_default`
+        Suggests available domain names for a business, brand, or Wix site.
+
+        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.
+
+        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.
+
+        Present the returned domains to the user as a short list. This tool only suggests domains — it does not purchase or connect them.
+      `,
       inputSchema: {
         query: zod_default.string().optional().describe(
           "Free-text keywords, business idea, or brand concept to base suggestions on. Use the user's own words."
@@ -41815,10 +41898,11 @@ function addSuggestedDomainTool(server, authStrategy) {
       },
       _meta: {
         securitySchemes: [{ type: "oauth2", scopes: ["offline_access"] }],
-        ui: { visibility: ["app"] },
+        // Model-visible so hosts (e.g. Microsoft 365 Copilot) can call it directly and show it
+        // in their debug info; 'app' keeps it callable from the site-builder widget.
+        ui: { visibility: ["app", "model"] },
         "openai/toolInvocation/invoking": "Fetching suggested domains",
-        "openai/toolInvocation/invoked": "Suggested domains retrieved",
-        "openai/visibility": "private"
+        "openai/toolInvocation/invoked": "Suggested domains retrieved"
       }
     },
     async (args, { panorama }) => {
@@ -41866,7 +41950,9 @@ function addSuggestedDomainTool(server, authStrategy) {
                 structuredContent: { domains: [] }
               };
             }
-            resolvedQuery = siteName;
+            if (isSearchableSiteName(siteName) || !resolvedQuery) {
+              resolvedQuery = siteName;
+            }
           } catch (error2) {
             panorama.logger().error(
               `[getSuggestedDomains] Error fetching site name for siteId: ${siteId}`,
@@ -42322,7 +42408,8 @@ function addWixSiteCreationTool(server, _authStrategy, options) {
       };
       const message = buildSiteCreationSelectorMessage(
         args.query,
-        args.customActions
+        args.customActions,
+        { plain: server.isMicrosoftCopilotClient() }
       );
       return withJsonContent({
         content: [
@@ -45178,10 +45265,14 @@ function addImportClaudeDesignTool(server, authStrategy, options) {
       try {
         designUrl = new URL(args.url);
       } catch {
-        return errorResult("Invalid design URL.");
+        return errorResult(
+          "Invalid design URL \u2014 this tool only accepts the claudeusercontent.com URL produced by Claude Design. For site files the user provided themselves, do not retry: send the user to https://www.wix.com/headless/drop?utm_campaign=mcp to upload them and get a live hosted site."
+        );
       }
       if (designUrl.protocol !== "https:" || !designUrl.hostname.endsWith(CLAUDE_USER_CONTENT_HOST_SUFFIX)) {
-        return errorResult("Invalid design URL.");
+        return errorResult(
+          "Invalid design URL \u2014 this tool only accepts the claudeusercontent.com URL produced by Claude Design. For site files the user provided themselves, do not retry: send the user to https://www.wix.com/headless/drop?utm_campaign=mcp to upload them and get a live hosted site."
+        );
       }
       const accountHeaders = await authStrategy.getAccountAuthHeaders();
       const wixstroOptions = { baseUrl: wixstroBaseUrl, accountHeaders };
@@ -45280,6 +45371,765 @@ function truncateResponse(content, maxChars = DEFAULT_MAX_CHARS) {
 Response was ~${estimatedTokens.toLocaleString()} tokens (limit: ${limitTokens.toLocaleString()}). Refine your code to return less data.`;
 }
 
+// src/graphql/constants.ts
+var WIX_GRAPHQL_ENDPOINT = "https://www.wixapis.com/graphql/alpha";
+var SEARCH_GRAPHQL_TOOL_NAME = "SearchWixGraphQLOperations";
+var INSPECT_GRAPHQL_TOOL_NAME = "InspectWixGraphQLSchema";
+var EXECUTE_GRAPHQL_TOOL_NAME = "ExecuteWixGraphQL";
+var GRAPHQL_TOOL_NAMES = [
+  SEARCH_GRAPHQL_TOOL_NAME,
+  INSPECT_GRAPHQL_TOOL_NAME,
+  EXECUTE_GRAPHQL_TOOL_NAME
+];
+
+// src/graphql/introspection.ts
+var TYPE_REF_FRAGMENT = `
+fragment TR on __Type { kind name ofType { kind name ofType { kind name ofType { kind name } } } }`;
+var ROOT_OPERATIONS_QUERY = `{
+  __schema {
+    queryType { fields { name description args { name type { ...TR } } type { ...TR } } }
+    mutationType { fields { name description args { name type { ...TR } } type { ...TR } } }
+  }
+}${TYPE_REF_FRAGMENT}`;
+var TYPE_DETAILS_FRAGMENT = `
+fragment TD on __Type {
+  kind name description
+  fields { name description type { ...TR } args { name type { ...TR } } }
+  inputFields { name description type { ...TR } defaultValue }
+  enumValues { name description }
+  possibleTypes { name }
+}`;
+var ROOT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+var rootCache;
+var typeCache = /* @__PURE__ */ new Map();
+function resetGraphqlSchemaCache() {
+  rootCache = void 0;
+  typeCache.clear();
+}
+var RETRY_DELAYS_MS = [800, 2e3, 4e3];
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function fetchWithRetry(fetchImpl, url, init, delays = RETRY_DELAYS_MS) {
+  let attempt = 0;
+  for (; ; ) {
+    const resp = await fetchImpl(url, init);
+    if (resp.status < 500 || attempt >= delays.length) return resp;
+    await sleep(delays[attempt++]);
+  }
+}
+async function postIntrospection(query, options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const endpoint = options.endpoint ?? WIX_GRAPHQL_ENDPOINT;
+  const resp = await fetchWithRetry(
+    fetchImpl,
+    endpoint,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({ query })
+    },
+    options.retryDelaysMs
+  );
+  const text = await resp.text();
+  if (!resp.ok) {
+    const body = /^\s*<(!doctype|html)/i.test(text) ? "(HTML error page \u2014 the endpoint is temporarily unavailable; try again in a moment)" : text.slice(0, 500);
+    throw new Error(
+      `GraphQL introspection failed (${resp.status} ${resp.statusText}): ${body}`
+    );
+  }
+  const json = JSON.parse(text);
+  if (json.errors?.length && !json.data) {
+    throw new Error(
+      `GraphQL introspection returned errors: ${JSON.stringify(json.errors).slice(0, 500)}`
+    );
+  }
+  return json.data;
+}
+function getRootOperations(options = {}) {
+  const now = Date.now();
+  if (rootCache && now - rootCache.fetchedAt < ROOT_CACHE_TTL_MS) {
+    return rootCache.promise;
+  }
+  const promise = postIntrospection(ROOT_OPERATIONS_QUERY, options).then(
+    (data) => {
+      const toOps = (fields, kind) => (fields ?? []).map((f2) => ({
+        kind,
+        name: f2.name,
+        description: f2.description ?? "",
+        args: f2.args ?? [],
+        type: f2.type
+      }));
+      return [
+        ...toOps(data?.__schema?.queryType?.fields, "query"),
+        ...toOps(data?.__schema?.mutationType?.fields, "mutation")
+      ];
+    }
+  );
+  promise.catch(() => {
+    if (rootCache?.promise === promise) rootCache = void 0;
+  });
+  rootCache = { promise, fetchedAt: now };
+  return promise;
+}
+var GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
+var TYPE_BATCH_SIZE = 10;
+async function getTypes(names, options = {}) {
+  const unique = [...new Set(names)].filter((n) => GRAPHQL_NAME.test(n));
+  const missing = unique.filter((n) => !typeCache.has(n));
+  for (let start = 0; start < missing.length; start += TYPE_BATCH_SIZE) {
+    const chunk = missing.slice(start, start + TYPE_BATCH_SIZE);
+    const selections = chunk.map((n, i) => `t${i}: __type(name: "${n}") { ...TD }`).join("\n");
+    const query = `{
+${selections}
+}${TYPE_DETAILS_FRAGMENT}${TYPE_REF_FRAGMENT}`;
+    const batch = postIntrospection(query, options);
+    chunk.forEach((n, i) => {
+      const p2 = batch.then(
+        (data) => data?.[`t${i}`] ?? null
+      );
+      p2.catch(() => {
+        if (typeCache.get(n) === p2) typeCache.delete(n);
+      });
+      typeCache.set(n, p2);
+    });
+    await batch.catch(() => void 0);
+  }
+  const result = /* @__PURE__ */ new Map();
+  await Promise.all(
+    unique.map(async (n) => {
+      result.set(n, await typeCache.get(n));
+    })
+  );
+  return result;
+}
+function renderTypeRef(ref) {
+  if (!ref) return "Unknown";
+  if (ref.kind === "NON_NULL") return `${renderTypeRef(ref.ofType)}!`;
+  if (ref.kind === "LIST") return `[${renderTypeRef(ref.ofType)}]`;
+  return ref.name ?? "Unknown";
+}
+function namedType(ref) {
+  let cur = ref;
+  while (cur && (cur.kind === "NON_NULL" || cur.kind === "LIST")) {
+    cur = cur.ofType ?? null;
+  }
+  return cur?.name ?? null;
+}
+var BUILTIN_SCALARS = /* @__PURE__ */ new Set([
+  "String",
+  "Int",
+  "Float",
+  "Boolean",
+  "ID",
+  "JSON"
+]);
+function isBuiltinScalar(name) {
+  return !!name && BUILTIN_SCALARS.has(name);
+}
+function oneLine(text, max) {
+  if (!text) return "";
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function renderField(field, isInput) {
+  const args = !isInput && field.args?.length ? `(${field.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ")})` : "";
+  const def = isInput && field.defaultValue != null ? ` = ${field.defaultValue}` : "";
+  const comment = field.description ? `  # ${oneLine(field.description, 140)}` : "";
+  return `  ${field.name}${args}: ${renderTypeRef(field.type)}${def}${comment}`;
+}
+function renderType(type) {
+  const references = /* @__PURE__ */ new Set();
+  const collect = (ref) => {
+    const n = namedType(ref);
+    if (n && !isBuiltinScalar(n) && n !== type.name) references.add(n);
+  };
+  const header = type.description ? `# ${oneLine(type.description, 200)}
+` : "";
+  let body;
+  switch (type.kind) {
+    case "ENUM":
+      body = `enum ${type.name} {
+${(type.enumValues ?? []).map(
+        (v) => `  ${v.name}${v.description ? `  # ${oneLine(v.description, 100)}` : ""}`
+      ).join("\n")}
+}`;
+      break;
+    case "INPUT_OBJECT":
+      (type.inputFields ?? []).forEach((f2) => collect(f2.type));
+      body = `input ${type.name} {
+${(type.inputFields ?? []).map((f2) => renderField(f2, true)).join("\n")}
+}`;
+      break;
+    case "UNION":
+      (type.possibleTypes ?? []).forEach((p2) => references.add(p2.name));
+      body = `union ${type.name} = ${(type.possibleTypes ?? []).map((p2) => p2.name).join(" | ")}`;
+      break;
+    case "SCALAR":
+      body = `scalar ${type.name}`;
+      break;
+    default: {
+      (type.fields ?? []).forEach((f2) => {
+        collect(f2.type);
+        f2.args?.forEach((a2) => collect(a2.type));
+      });
+      const keyword = type.kind === "INTERFACE" ? "interface" : "type";
+      body = `${keyword} ${type.name} {
+${(type.fields ?? []).map((f2) => renderField(f2, false)).join("\n")}
+}`;
+    }
+  }
+  return { text: header + body, references: [...references] };
+}
+function renderOperationSignature(op) {
+  const args = op.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ");
+  return `${op.kind === "query" ? "Query" : "Mutation"}.${op.name}(${args}): ${renderTypeRef(op.type)}`;
+}
+async function expandTypes(rootTypeNames, options = {}) {
+  const depth = Math.max(1, Math.min(options.depth ?? 2, 5));
+  const maxTypes = options.maxTypes ?? 40;
+  const rendered = [];
+  const unknown2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  let frontier = [...new Set(rootTypeNames)].filter((n) => !isBuiltinScalar(n));
+  let level = 1;
+  let overflow = [];
+  while (frontier.length > 0 && level <= depth) {
+    const room = maxTypes - seen.size;
+    if (room <= 0) {
+      overflow = frontier;
+      break;
+    }
+    const batch = frontier.slice(0, room);
+    overflow = frontier.slice(room);
+    batch.forEach((n) => seen.add(n));
+    const types = await getTypes(batch, options);
+    const next = /* @__PURE__ */ new Set();
+    for (const name of batch) {
+      const type = types.get(name);
+      if (!type) {
+        unknown2.push(name);
+        continue;
+      }
+      const { text, references } = renderType(type);
+      rendered.push(text);
+      references.forEach((r) => {
+        if (!seen.has(r)) next.add(r);
+      });
+    }
+    frontier = [...next];
+    level++;
+  }
+  const unexpanded = [.../* @__PURE__ */ new Set([...overflow, ...frontier])].filter(
+    (n) => !seen.has(n) && !isBuiltinScalar(n)
+  );
+  return { rendered, unexpanded, unknown: unknown2 };
+}
+
+// src/graphql/search.ts
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-zA-Z])([0-9])/g, "$1 $2").replace(/([0-9])([a-zA-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "of",
+  "for",
+  "to",
+  "in",
+  "on",
+  "with",
+  "and",
+  "or",
+  "by",
+  "all",
+  "my",
+  "me",
+  "i",
+  "from",
+  "is",
+  "are",
+  "be",
+  "it",
+  "this",
+  "that",
+  "wix",
+  "api",
+  "graphql"
+]);
+function stem(token) {
+  if (token.length > 4 && token.endsWith("ies"))
+    return `${token.slice(0, -3)}y`;
+  if (token.length > 3 && token.endsWith("es") && !token.endsWith("ses"))
+    return token.slice(0, -1);
+  if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss"))
+    return token.slice(0, -1);
+  return token;
+}
+var VERB_SYNONYMS = {
+  list: ["query", "list", "search"],
+  find: ["query", "search", "get"],
+  fetch: ["get", "query"],
+  read: ["get", "query"],
+  show: ["get", "query"],
+  count: ["count", "query"],
+  add: ["create", "add"],
+  new: ["create"],
+  insert: ["create"],
+  edit: ["update"],
+  change: ["update"],
+  modify: ["update"],
+  set: ["update"],
+  remove: ["delete", "remove"],
+  destroy: ["delete"],
+  cancel: ["cancel", "delete"],
+  customer: ["contact", "member"],
+  client: ["contact", "member"],
+  item: ["product", "item"],
+  inventory: ["inventory", "stock"],
+  stock: ["inventory", "stock"],
+  post: ["post", "blog"],
+  article: ["post", "blog"],
+  appointment: ["booking", "session"],
+  collection: ["collection", "category", "data"],
+  cms: ["data", "collection"],
+  store: ["stores", "store"]
+};
+function expandQueryTokens(tokens) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of tokens) {
+    if (STOP_WORDS.has(raw)) continue;
+    const s2 = stem(raw);
+    out.add(s2);
+    for (const syn of VERB_SYNONYMS[raw] ?? VERB_SYNONYMS[s2] ?? []) {
+      out.add(stem(syn));
+    }
+  }
+  return out;
+}
+var READ_VERBS = /* @__PURE__ */ new Set([
+  "list",
+  "get",
+  "query",
+  "find",
+  "fetch",
+  "read",
+  "show",
+  "retrieve",
+  "search",
+  "count",
+  "view",
+  "see"
+]);
+var WRITE_VERBS = /* @__PURE__ */ new Set([
+  "create",
+  "add",
+  "new",
+  "insert",
+  "update",
+  "edit",
+  "change",
+  "modify",
+  "set",
+  "delete",
+  "remove",
+  "destroy",
+  "cancel",
+  "bulk",
+  "merge",
+  "publish",
+  "send"
+]);
+var isVersionToken = (t) => t === "v" || /^\d+$/.test(t);
+function stripMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[`*_]/g, "");
+}
+function firstSentence(text, max = 220) {
+  const flat = stripMarkdown(text).replace(/\s+/g, " ").trim();
+  const cut = flat.search(/(?<=[.!?])\s/);
+  const sentence = cut > 0 ? flat.slice(0, cut) : flat;
+  return sentence.length > max ? `${sentence.slice(0, max - 1)}\u2026` : sentence;
+}
+var indexCache = /* @__PURE__ */ new WeakMap();
+function indexOperations(ops) {
+  let indexed = indexCache.get(ops);
+  if (!indexed) {
+    indexed = ops.map((op) => ({
+      op,
+      nameTokens: new Set(tokenize(op.name).map(stem)),
+      descTokens: new Set(tokenize(op.description.slice(0, 600)).map(stem))
+    }));
+    indexCache.set(ops, indexed);
+  }
+  return indexed;
+}
+function searchOperations(ops, query, options = {}) {
+  const { kind = "all", maxResults = 10 } = options;
+  const rawTokens = tokenize(query);
+  const terms = expandQueryTokens(rawTokens);
+  const originalTerms = new Set(
+    rawTokens.filter((t) => !STOP_WORDS.has(t)).map(stem)
+  );
+  const exactName = query.trim();
+  const hasWriteVerb = rawTokens.some((t) => WRITE_VERBS.has(t));
+  const nounTokens = rawTokens.filter(
+    (t) => !STOP_WORDS.has(t) && !READ_VERBS.has(t) && !WRITE_VERBS.has(t)
+  );
+  const pluralIntent = nounTokens.length > 0 && nounTokens.some((t) => stem(t) !== t);
+  const readIntent = !hasWriteVerb;
+  const matches = [];
+  for (const { op, nameTokens, descTokens } of indexOperations(ops)) {
+    if (kind !== "all" && op.kind !== kind) continue;
+    let score = 0;
+    let originalHits = 0;
+    const matchedNameTokens = /* @__PURE__ */ new Set();
+    for (const term of terms) {
+      const isOriginal = originalTerms.has(term);
+      if (op.kind === "query" && readIntent && READ_VERBS.has(term)) {
+        score += isOriginal ? 4 : 2;
+        if (isOriginal) originalHits++;
+        if (nameTokens.has(term)) matchedNameTokens.add(term);
+        continue;
+      }
+      if (nameTokens.has(term)) {
+        matchedNameTokens.add(term);
+        score += isOriginal ? 4 : 2;
+        if (isOriginal) originalHits++;
+        continue;
+      }
+      let prefixHit = false;
+      for (const nt2 of nameTokens) {
+        if (term.length >= 3 && (nt2.startsWith(term) || term.startsWith(nt2))) {
+          prefixHit = true;
+          matchedNameTokens.add(nt2);
+          break;
+        }
+      }
+      if (prefixHit) {
+        score += isOriginal ? 2 : 1;
+        if (isOriginal) originalHits++;
+        continue;
+      }
+      if (descTokens.has(term)) {
+        score += 1;
+        if (isOriginal) originalHits++;
+      }
+    }
+    if (score <= 0 && op.name !== exactName) continue;
+    if (op.name === exactName) score += 100;
+    if (originalTerms.size > 0 && originalHits === originalTerms.size) {
+      score += 3;
+    }
+    const lastToken = tokenize(op.name).filter((t) => !isVersionToken(t)).pop();
+    if (lastToken && nounTokens.length > 0) {
+      const pluralOp = stem(lastToken) !== lastToken;
+      score += pluralOp === pluralIntent ? 0.5 : -0.5;
+    }
+    if (/DoNotCall/i.test(op.name)) score -= 2;
+    for (const nt2 of nameTokens) {
+      if (!isVersionToken(nt2) && !matchedNameTokens.has(nt2)) score -= 0.3;
+    }
+    if (readIntent && op.kind === "mutation" && [...nameTokens].some((t) => WRITE_VERBS.has(t))) {
+      score -= 6;
+    }
+    if (op.kind === "query" && readIntent) score += 1;
+    const version2 = op.name.match(/V(\d+)/);
+    if (version2) score += Math.min(Number(version2[1]), 5) * 0.1;
+    if (!op.description) score -= 0.5;
+    score -= op.name.length / 200;
+    if (score <= 0) continue;
+    matches.push({
+      operation: op.name,
+      kind: op.kind,
+      signature: `${op.name}(${op.args.map((a2) => `${a2.name}: ${renderTypeRef(a2.type)}`).join(", ")}): ${renderTypeRef(op.type)}`,
+      description: firstSentence(op.description),
+      inputType: op.args[0] ? namedType(op.args[0].type) : null,
+      returnType: namedType(op.type),
+      score: Math.round(score * 100) / 100
+    });
+  }
+  matches.sort(
+    (a2, b2) => b2.score - a2.score || a2.operation.localeCompare(b2.operation)
+  );
+  return matches.slice(0, Math.max(1, Math.min(maxResults, 50)));
+}
+
+// src/graphql/index.ts
+var textResult = (text) => ({
+  content: [{ type: "text", text }]
+});
+var errorResult2 = (text) => ({
+  isError: true,
+  content: [{ type: "text", text }]
+});
+var SCHEMA_MAX_RESPONSE_CHARS = 48e3;
+function addGraphqlTools(server, options = {}) {
+  const { authStrategy, disableTools = [], toolDescriptions } = options;
+  const getDescription = (name) => toolDescriptions?.[name] ?? defaultToolDescriptions[name];
+  if (!disableTools.includes(SEARCH_GRAPHQL_TOOL_NAME)) {
+    addSearchGraphqlTool(
+      server,
+      getDescription(SEARCH_GRAPHQL_TOOL_NAME),
+      options
+    );
+  }
+  if (!disableTools.includes(INSPECT_GRAPHQL_TOOL_NAME)) {
+    addInspectGraphqlTool(
+      server,
+      getDescription(INSPECT_GRAPHQL_TOOL_NAME),
+      options
+    );
+  }
+  if (authStrategy && !disableTools.includes(EXECUTE_GRAPHQL_TOOL_NAME)) {
+    addExecuteGraphqlTool(
+      server,
+      getDescription(EXECUTE_GRAPHQL_TOOL_NAME),
+      authStrategy,
+      options
+    );
+  }
+}
+function introspectionOptions(options) {
+  return {
+    endpoint: options.endpoint,
+    fetchImpl: options.fetchImpl,
+    retryDelaysMs: options.retryDelaysMs
+  };
+}
+function addSearchGraphqlTool(server, description, options) {
+  const d2 = desc("SearchWixGraphQLOperations");
+  server.tool(
+    SEARCH_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      query: external_exports.string().describe(d2.query),
+      kind: external_exports.enum(["query", "mutation", "all"]).optional().describe(d2.kind),
+      maxResults: external_exports.number().int().min(1).max(50).optional().describe(d2.maxResults),
+      reason: external_exports.string().describe(d2.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ query, kind, maxResults, reason }) => {
+      logger2.log(
+        `[${SEARCH_GRAPHQL_TOOL_NAME}] query="${query}" kind=${kind ?? "all"} reason="${reason}"`
+      );
+      try {
+        const ops = await getRootOperations(introspectionOptions(options));
+        const matches = searchOperations(ops, query, {
+          kind: kind ?? "all",
+          maxResults: maxResults ?? 10
+        });
+        if (matches.length === 0) {
+          return textResult(
+            `No GraphQL operations matched "${query}". Try other words for the entity (e.g. "contact" instead of "customer", "product" instead of "item") or the verb (query/get/create/update/delete), or search a single noun.`
+          );
+        }
+        const lines = matches.map(
+          (m2, i) => `${i + 1}. ${m2.kind} ${m2.signature}
+   ${m2.description || "(no description)"}`
+        );
+        const text = [
+          `Top ${matches.length} of ${ops.length} Wix GraphQL root operations for "${query}":`,
+          "",
+          ...lines,
+          "",
+          `Next: call ${INSPECT_GRAPHQL_TOOL_NAME} with \`operation\` set to the chosen name to read its exact input type and return type before writing the request.`
+        ].join("\n");
+        return textResult(text);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${SEARCH_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult2(`GraphQL schema search error: ${message}`);
+      }
+    }
+  );
+}
+function addInspectGraphqlTool(server, description, options) {
+  const d2 = desc("InspectWixGraphQLSchema");
+  const maxChars = options.maxResponseSize ?? SCHEMA_MAX_RESPONSE_CHARS;
+  server.tool(
+    INSPECT_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      operation: external_exports.string().optional().describe(d2.operation),
+      typeNames: external_exports.array(external_exports.string()).optional().describe(d2.typeNames),
+      depth: external_exports.number().int().min(1).max(4).optional().describe(d2.depth),
+      reason: external_exports.string().describe(d2.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ operation, typeNames, depth, reason }) => {
+      logger2.log(
+        `[${INSPECT_GRAPHQL_TOOL_NAME}] operation=${operation ?? "-"} typeNames=${JSON.stringify(typeNames ?? [])} depth=${depth ?? 2} reason="${reason}"`
+      );
+      if (!operation && !(typeNames && typeNames.length > 0)) {
+        return errorResult2(
+          "Pass `operation` (a root query/mutation name from SearchWixGraphQLOperations) and/or `typeNames` (type names to expand)."
+        );
+      }
+      try {
+        const io2 = introspectionOptions(options);
+        const sections = [];
+        const roots = [];
+        if (operation) {
+          const ops = await getRootOperations(io2);
+          const op = ops.find((o) => o.name === operation);
+          if (!op) {
+            const suggestions = searchOperations(ops, operation, {
+              maxResults: 5
+            });
+            return errorResult2(
+              `No root operation named "${operation}". ${suggestions.length ? `Did you mean: ${suggestions.map((s2) => `${s2.kind} ${s2.operation}`).join(", ")}? Use SearchWixGraphQLOperations to discover the exact name.` : "Use SearchWixGraphQLOperations to discover the exact name."}`
+            );
+          }
+          sections.push(
+            `# ${renderOperationSignature(op)}`,
+            op.description ? op.description.trim().split("\n").map((l) => `# ${l}`).join("\n") : "# (no description)"
+          );
+          op.args.forEach((a2) => {
+            const n = namedType(a2.type);
+            if (n) roots.push(n);
+          });
+          const ret = namedType(op.type);
+          if (ret) roots.push(ret);
+        }
+        if (typeNames?.length) roots.push(...typeNames);
+        const { rendered, unexpanded, unknown: unknown2 } = await expandTypes(roots, {
+          ...io2,
+          depth: depth ?? 2
+        });
+        sections.push(...rendered);
+        if (unknown2.length) {
+          sections.push(
+            `# Unknown type names (not in the schema): ${unknown2.join(", ")}`
+          );
+        }
+        if (unexpanded.length) {
+          sections.push(
+            `# Not expanded (pass any of these in \`typeNames\` to read them): ${unexpanded.join(", ")}`
+          );
+        }
+        sections.push(
+          "# Notes: `JSON` scalar fields (filter, sort, free-form data) take any JSON \u2014 pass them as variables. Every object-typed field in a selection needs its own { ... } selection set. Only fields listed above exist. Paging: use exactly the paging style the input type declares \u2014 `paging` (offset) or `cursorPaging` (cursor) \u2014 never the other one. `pageInfo.total` is only populated with offset paging; with cursor paging, count by walking pages (`pageInfo.hasNext` + cursor) or use a dedicated count operation if one exists."
+        );
+        return textResult(truncateResponse(sections.join("\n\n"), maxChars));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${INSPECT_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult2(`GraphQL schema inspection error: ${message}`);
+      }
+    }
+  );
+}
+function addExecuteGraphqlTool(server, description, authStrategy, options) {
+  const d2 = desc("ExecuteWixGraphQL");
+  const endpoint = options.endpoint ?? WIX_GRAPHQL_ENDPOINT;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  server.tool(
+    EXECUTE_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      query: external_exports.string().describe(d2.query),
+      variables: external_exports.record(external_exports.unknown()).optional().describe(d2.variables),
+      operationName: external_exports.string().optional().describe(d2.operationName),
+      siteId: external_exports.string().optional().describe(d2.siteId),
+      scope: external_exports.enum(["site", "account"]).optional().describe(d2.scope),
+      hasMutations: external_exports.boolean().describe(d2.hasMutations),
+      reason: external_exports.string().describe(d2.reason)
+    },
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+    async ({ query, variables, operationName, siteId, scope, hasMutations, reason }, extra) => {
+      const effectiveScope = scope ?? (siteId ? "site" : "account");
+      logger2.log(
+        `[${EXECUTE_GRAPHQL_TOOL_NAME}] scope=${effectiveScope} siteId=${siteId ?? "none"} hasMutations=${hasMutations} operationName=${operationName ?? "-"} reason="${reason}"`
+      );
+      if (effectiveScope === "site" && !siteId) {
+        return errorResult2(
+          'A `siteId` is required for site-level GraphQL operations (anything that reads or writes inside a site). Resolve it with GetSiteContext or ListWixSites, or set scope: "account" for account-level operations.'
+        );
+      }
+      if (!query.trim()) {
+        return errorResult2("`query` must be a non-empty GraphQL document.");
+      }
+      const authHeaders = effectiveScope === "site" ? await authStrategy.getSiteAuthHeaders(siteId) : await authStrategy.getAccountAuthHeaders();
+      try {
+        const init = {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...authHeaders
+          },
+          body: JSON.stringify({
+            query,
+            ...variables ? { variables } : {},
+            ...operationName ? { operationName } : {}
+          })
+        };
+        const resp = hasMutations ? await fetchImpl(endpoint, init) : await fetchWithRetry(
+          fetchImpl,
+          endpoint,
+          init,
+          options.retryDelaysMs
+        );
+        const requestId = resp.headers?.get("x-wix-request-id") ?? void 0;
+        extra?.setToolBiParams?.({ siteId, requestId });
+        const text = await resp.text();
+        if (!resp.ok) {
+          await authStrategy.enforceValidWixToken?.({
+            status: resp.status,
+            response: { status: resp.status }
+          });
+          const body2 = /^\s*<(!doctype|html)/i.test(text) ? "(HTML error page)" : text.slice(0, 2e3);
+          const hasObjectVariables = !!variables && Object.values(variables).some(
+            (v) => v !== null && typeof v === "object"
+          );
+          const hint = resp.status >= 500 ? hasObjectVariables ? ` The Wix GraphQL endpoint (Developer Preview) returns 503 when an object-typed variable carries an enum value. Rewrite the document with the input INLINE as a GraphQL literal (enum values unquoted, e.g. productType: PHYSICAL), keep variables only for JSON scalars and plain scalars, and retry once. If it still fails and REST tools (ExecuteWixAPI / CallWixSiteAPI) are available, use the equivalent REST method.` : ` The Wix GraphQL endpoint (Developer Preview) failed for this operation. Do not retry the same document more than once. If REST tools (ExecuteWixAPI / CallWixSiteAPI) are available, complete the task through the equivalent REST method instead; otherwise report the failure with the request id.` : "";
+          return errorResult2(
+            `Wix GraphQL request failed: ${resp.status} ${resp.statusText}.${requestId ? ` request id: ${requestId}.` : ""}${hint}
+${body2}`
+          );
+        }
+        let json;
+        try {
+          json = JSON.parse(text);
+        } catch {
+          return errorResult2(
+            `Wix GraphQL returned a non-JSON body:
+${text.slice(0, 2e3)}`
+          );
+        }
+        const hasData = json.data != null && Object.values(json.data).some((v) => v !== null && v !== void 0);
+        const errors = json.errors ?? [];
+        if (!hasData && errors.length > 0) {
+          const permissionDenied = errors.some(
+            (e) => e.extensions?.message === "PERMISSION_DENIED"
+          );
+          return errorResult2(
+            [
+              `Wix GraphQL returned errors and no data${requestId ? ` (request id: ${requestId})` : ""}:`,
+              JSON.stringify(errors, null, 2).slice(0, 4e3),
+              permissionDenied ? "PERMISSION_DENIED usually means the operation is site-level and was called without the right `siteId`, the app behind it is not installed on the site, or the credential lacks that permission scope." : 'Validation errors ("Cannot query field ...", "Unknown argument ...") mean a name was guessed \u2014 re-read the exact fields with InspectWixGraphQLSchema and retry.'
+            ].join("\n")
+          );
+        }
+        const body = { data: json.data };
+        if (errors.length > 0) {
+          body.errors = errors;
+          body.note = "Partial result: some root fields failed (see errors[].path). Fields present in data succeeded.";
+        }
+        return textResult(truncateResponse(body, options.maxResponseSize));
+      } catch (err) {
+        rethrowIfUnauthorized(err);
+        await authStrategy.enforceValidWixToken?.(err);
+        const message = err instanceof Error ? err.message : String(err);
+        logger2.log(`[${EXECUTE_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult2(`Wix GraphQL execution error: ${message}`);
+      }
+    }
+  );
+}
+
 // src/code-mode/validation.ts
 var EXECUTE_FUNCTION_EXPRESSION_HINT = 'ExecuteWixAPI code must be a function expression, not a script body. Pass code like: async () => { const response = await wix.request({ scope: "site", method: "GET", url: "https://www.wixapis.com/..." }); return response.data; }. Do not write top-level const/await/return outside the function and do not invoke the function yourself.';
 function validateExecuteCode(code) {
@@ -45765,6 +46615,20 @@ function createWixToolkit(options) {
         maxResponseSize
       });
     }
+    const requestedGraphqlTools = GRAPHQL_TOOL_NAMES.filter(
+      (name) => requestedTools.has(name)
+    );
+    if (requestedGraphqlTools.length > 0) {
+      addGraphqlTools(server, {
+        authStrategy,
+        disableTools: [
+          ...disableTools ?? [],
+          ...GRAPHQL_TOOL_NAMES.filter((n) => !requestedTools.has(n))
+        ],
+        toolDescriptions: effectiveToolDescriptions,
+        maxResponseSize
+      });
+    }
   } else {
     addApiCallTool(
       server,
@@ -45950,13 +46814,17 @@ export {
   DEFAULT_OPENAI_SECURITY_SCHEMES,
   EDIT_SITE_TOOL_NAME,
   EXECUTE_FUNCTION_EXPRESSION_HINT,
+  EXECUTE_GRAPHQL_TOOL_NAME,
   GET_SUGGESTED_DOMAINS_TOOL_NAME,
+  GRAPHQL_TOOL_NAMES,
   IMPORT_CLAUDE_DESIGN_TOOL_NAME,
+  INSPECT_GRAPHQL_TOOL_NAME,
   MENU_CONTENT_THRESHOLD,
   OPENAI_WIDGET_MIME_TYPE,
   OPEN_AI_SITE_WIDGET_CSP,
   PULL_SITE_JOB_TOOL_NAME,
   RECIPES_INDEX_URL,
+  SEARCH_GRAPHQL_TOOL_NAME,
   SEARCH_SITE_TEMPLATES_TOOL_NAME,
   SITE_BUILDER_TOOL_NAME,
   SITE_CREATION_COPY,
@@ -45969,6 +46837,7 @@ export {
   VALID_DOCS_TOOLS,
   WIXEL_ICON_PNG_URL,
   WIXEL_ICON_SVG_URL,
+  WIX_GRAPHQL_ENDPOINT,
   WIX_SITE_CREATION_TOOL_NAME,
   WixFetchError,
   WixMcpServer,
@@ -45985,6 +46854,7 @@ export {
   addGetWixelAssetTool,
   addGetWixelJobStatusTool,
   addGetWixelProjectAssetsTool,
+  addGraphqlTools,
   addImportClaudeDesignTool,
   addListWixelEventsTool,
   addMarkWixelJobAsFulfilledTool,
@@ -45994,6 +46864,7 @@ export {
   addSendWixelMessageTool,
   addSiteCreationWidgetTools,
   addStartWixelSessionTool,
+  addSuggestedDomainTool,
   addSupportTool,
   addWixSiteCreationTool,
   addWixelSessionTools,
@@ -46018,6 +46889,7 @@ export {
   mergeConfig,
   normalizeMenuContent,
   parseDirectChildren,
+  resetGraphqlSchemaCache,
   rethrowIfUnauthorized,
   summarizeLargeMenu,
   toWidget,