@wix/mcp 1.0.81 → 1.0.83

package/build/esm/toolkit.js

@@ -12177,6 +12177,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.
@@ -12509,7 +12511,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.
@@ -12906,10 +12909,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
 
@@ -13024,7 +13054,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 = {
@@ -13375,7 +13406,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 = (hostname) => hostname === "wix.com" || hostname.endsWith(".wix.com");
+var dynamicContextUrl = () => {
+  if (typeof window === "undefined") {
+    return DYNAMIC_CONTEXT_URL;
+  }
+  const hostname = window.location?.hostname;
+  return typeof hostname === "string" && isWixHost(hostname) ? 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";
@@ -13427,7 +13467,7 @@ async function getDynamicContext(auth, httpClient, filter, options) {
     if (filter?.siteId) body.site_id = filter.siteId;
     else if (filter?.siteName) body.site_name = filter.siteName;
     const dynamicContextPromise = httpClient.request({
-      url: DYNAMIC_CONTEXT_URL,
+      url: dynamicContextUrl(),
       method: "POST",
       headers: {
         ...accountHeaders,
@@ -13621,6 +13661,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.",
@@ -15607,6 +15668,761 @@ 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();
+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((f) => ({
+        kind,
+        name: f.name,
+        description: f.description ?? "",
+        args: f.args ?? [],
+        type: f.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 p = batch.then(
+        (data) => data?.[`t${i}`] ?? null
+      );
+      p.catch(() => {
+        if (typeCache.get(n) === p) typeCache.delete(n);
+      });
+      typeCache.set(n, p);
+    });
+    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((a) => `${a.name}: ${renderTypeRef(a.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((f) => collect(f.type));
+      body = `input ${type.name} {
+${(type.inputFields ?? []).map((f) => renderField(f, true)).join("\n")}
+}`;
+      break;
+    case "UNION":
+      (type.possibleTypes ?? []).forEach((p) => references.add(p.name));
+      body = `union ${type.name} = ${(type.possibleTypes ?? []).map((p) => p.name).join(" | ")}`;
+      break;
+    case "SCALAR":
+      body = `scalar ${type.name}`;
+      break;
+    default: {
+      (type.fields ?? []).forEach((f) => {
+        collect(f.type);
+        f.args?.forEach((a) => collect(a.type));
+      });
+      const keyword = type.kind === "INTERFACE" ? "interface" : "type";
+      body = `${keyword} ${type.name} {
+${(type.fields ?? []).map((f) => renderField(f, false)).join("\n")}
+}`;
+    }
+  }
+  return { text: header + body, references: [...references] };
+}
+function renderOperationSignature(op) {
+  const args = op.args.map((a) => `${a.name}: ${renderTypeRef(a.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 unknown = [];
+  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) {
+        unknown.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 };
+}
+
+// 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 s = stem(raw);
+    out.add(s);
+    for (const syn of VERB_SYNONYMS[raw] ?? VERB_SYNONYMS[s] ?? []) {
+      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 nt of nameTokens) {
+        if (term.length >= 3 && (nt.startsWith(term) || term.startsWith(nt))) {
+          prefixHit = true;
+          matchedNameTokens.add(nt);
+          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 nt of nameTokens) {
+      if (!isVersionToken(nt) && !matchedNameTokens.has(nt)) 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 version = op.name.match(/V(\d+)/);
+    if (version) score += Math.min(Number(version[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((a) => `${a.name}: ${renderTypeRef(a.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(
+    (a, b) => b.score - a.score || a.operation.localeCompare(b.operation)
+  );
+  return matches.slice(0, Math.max(1, Math.min(maxResults, 50)));
+}
+
+// src/graphql/index.ts
+var textResult = (text) => ({
+  content: [{ type: "text", text }]
+});
+var errorResult = (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 d = desc("SearchWixGraphQLOperations");
+  server.tool(
+    SEARCH_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      query: external_exports.string().describe(d.query),
+      kind: external_exports.enum(["query", "mutation", "all"]).optional().describe(d.kind),
+      maxResults: external_exports.number().int().min(1).max(50).optional().describe(d.maxResults),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ query, kind, maxResults, reason }) => {
+      logger.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(
+          (m, i) => `${i + 1}. ${m.kind} ${m.signature}
+   ${m.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);
+        logger.log(`[${SEARCH_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`GraphQL schema search error: ${message}`);
+      }
+    }
+  );
+}
+function addInspectGraphqlTool(server, description, options) {
+  const d = desc("InspectWixGraphQLSchema");
+  const maxChars = options.maxResponseSize ?? SCHEMA_MAX_RESPONSE_CHARS;
+  server.tool(
+    INSPECT_GRAPHQL_TOOL_NAME,
+    description,
+    {
+      operation: external_exports.string().optional().describe(d.operation),
+      typeNames: external_exports.array(external_exports.string()).optional().describe(d.typeNames),
+      depth: external_exports.number().int().min(1).max(4).optional().describe(d.depth),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+    async ({ operation, typeNames, depth, reason }) => {
+      logger.log(
+        `[${INSPECT_GRAPHQL_TOOL_NAME}] operation=${operation ?? "-"} typeNames=${JSON.stringify(typeNames ?? [])} depth=${depth ?? 2} reason="${reason}"`
+      );
+      if (!operation && !(typeNames && typeNames.length > 0)) {
+        return errorResult(
+          "Pass `operation` (a root query/mutation name from SearchWixGraphQLOperations) and/or `typeNames` (type names to expand)."
+        );
+      }
+      try {
+        const io = introspectionOptions(options);
+        const sections = [];
+        const roots = [];
+        if (operation) {
+          const ops = await getRootOperations(io);
+          const op = ops.find((o) => o.name === operation);
+          if (!op) {
+            const suggestions = searchOperations(ops, operation, {
+              maxResults: 5
+            });
+            return errorResult(
+              `No root operation named "${operation}". ${suggestions.length ? `Did you mean: ${suggestions.map((s) => `${s.kind} ${s.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((a) => {
+            const n = namedType(a.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 } = await expandTypes(roots, {
+          ...io,
+          depth: depth ?? 2
+        });
+        sections.push(...rendered);
+        if (unknown.length) {
+          sections.push(
+            `# Unknown type names (not in the schema): ${unknown.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);
+        logger.log(`[${INSPECT_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`GraphQL schema inspection error: ${message}`);
+      }
+    }
+  );
+}
+function addExecuteGraphqlTool(server, description, authStrategy, options) {
+  const d = 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(d.query),
+      variables: external_exports.record(external_exports.unknown()).optional().describe(d.variables),
+      operationName: external_exports.string().optional().describe(d.operationName),
+      siteId: external_exports.string().optional().describe(d.siteId),
+      scope: external_exports.enum(["site", "account"]).optional().describe(d.scope),
+      hasMutations: external_exports.boolean().describe(d.hasMutations),
+      reason: external_exports.string().describe(d.reason)
+    },
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+    async ({ query, variables, operationName, siteId, scope, hasMutations, reason }, extra) => {
+      const effectiveScope = scope ?? (siteId ? "site" : "account");
+      logger.log(
+        `[${EXECUTE_GRAPHQL_TOOL_NAME}] scope=${effectiveScope} siteId=${siteId ?? "none"} hasMutations=${hasMutations} operationName=${operationName ?? "-"} reason="${reason}"`
+      );
+      if (effectiveScope === "site" && !siteId) {
+        return errorResult(
+          '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 errorResult("`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 errorResult(
+            `Wix GraphQL request failed: ${resp.status} ${resp.statusText}.${requestId ? ` request id: ${requestId}.` : ""}${hint}
+${body2}`
+          );
+        }
+        let json;
+        try {
+          json = JSON.parse(text);
+        } catch {
+          return errorResult(
+            `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 errorResult(
+            [
+              `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);
+        logger.log(`[${EXECUTE_GRAPHQL_TOOL_NAME}] Error: ${message}`);
+        return errorResult(`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) {
@@ -17927,6 +18743,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,
@@ -18108,10 +18938,15 @@ function createWixToolkit(options) {
 }
 export {
   EXECUTE_FUNCTION_EXPRESSION_HINT,
+  EXECUTE_GRAPHQL_TOOL_NAME,
+  GRAPHQL_TOOL_NAMES,
+  INSPECT_GRAPHQL_TOOL_NAME,
   RECIPES_INDEX_URL,
+  SEARCH_GRAPHQL_TOOL_NAME,
   SYSTEM_REMINDER,
   SYSTEM_REMINDER_GUIDELINES,
   UNAUTHORIZED_ERROR_NAME,
+  WIX_GRAPHQL_ENDPOINT,
   WixFetchError,
   attachConsoleLogger,
   createWixToolkit,