@wix/mcp 1.0.94 → 1.0.96

package/build/dts/docs/get-to-know.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import dedent from 'dedent';
-import { fetchArticleContent, RECIPES_INDEX_URL } from './fetch-article.js';
+import { fetchArticleContent, fetchSourceContent, RECIPES_INDEX_URL } from './fetch-article.js';
 import { getSkillsByPortal } from './fetch-skills.js';
 import { REST_PORTAL_ID } from '../constants.js';
 // import { generateDocsNavigationTree } from './normalize-menu-content.js';
@@ -8,8 +8,13 @@ import { rethrowIfUnauthorized } from '../auth/index.js';
 import { defaultToolDescriptions, defaultReadmeDocs } from '../config/default-config.js';
 import { getDynamicContext } from '@wix/dynamic-context-enricher';
 import { desc } from '../config/param-descriptions.js';
+import { isMintlifyDocsSite, rewriteDocsLinks } from './mintlify-docs.js';
 export { getDynamicContext };
-export function addGetSiteContextTool({ server, authStrategy, toolDescriptions }) {
+// The management index as authored in ax-skills, which also holds skills its
+// public mirror (and so the published article) leaves out.
+const AX_SKILLS_REPO = 'wix-private/ax-skills';
+const AX_SKILLS_INDEX_PATH = 'skills/wix-manage/SKILL.md';
+export function addGetSiteContextTool({ server, authStrategy, includeCompanionApp = false, toolDescriptions }) {
     const d = desc('GetSiteContext');
     server.tool('GetSiteContext', toolDescriptions?.['GetSiteContext'] ??
         defaultToolDescriptions.GetSiteContext, {
@@ -35,7 +40,8 @@ export function addGetSiteContextTool({ server, authStrategy, toolDescriptions }
         try {
             context = await getDynamicContext(authStrategy, httpClient, filter, {
                 partnerContextEnabled: false,
-                includeAccountContext: false
+                includeAccountContext: false,
+                includeCompanionApp
             });
         }
         catch (err) {
@@ -61,14 +67,19 @@ export function addGetSiteContextTool({ server, authStrategy, toolDescriptions }
         };
     });
 }
-export async function addGetToKnowTools({ server, disableTools = [], toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, dynamicContextEnabled, repo, commitHash, skillsTags }) {
+export async function addGetToKnowTools({ server, disableTools = [], toolDescriptions, readmeDocs, authStrategy, skillsPortalUrl, dynamicContextEnabled, repo, commitHash, skillsTags, readmeRecipesIndexEnabled = true, docsSite }) {
     if (disableTools.includes('WixREADME')) {
         return;
     }
     // Use provided docs or fall back to defaults. The Recipes block is appended
     // at the end so the hand-authored wix-usage-guide stays on top.
     const baseDocs = readmeDocs ?? defaultReadmeDocs;
-    const baseDocsWithoutRecipes = baseDocs.filter((doc) => doc.url !== RECIPES_INDEX_URL);
+    // The list's page and its .md form are the same document.
+    const isRecipesIndex = (doc) => doc.url?.replace(/\.md$/, '') === RECIPES_INDEX_URL;
+    const baseDocsWithoutRecipes = baseDocs.filter((doc) => !isRecipesIndex(doc));
+    const recipesIndexDocs = readmeRecipesIndexEnabled
+        ? baseDocs.filter(isRecipesIndex)
+        : [];
     server.tool('WixREADME', toolDescriptions?.['WixREADME'] ?? defaultToolDescriptions.WixREADME, {}, { readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async (args, { httpClient }) => {
         // The schema is intentionally argless so the LLM always calls WixREADME
         // account-wide. A specific site can still be targeted programmatically
@@ -130,6 +141,15 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
                 if (!url) {
                     throw new Error('URL is required for "include" action');
                 }
+                const readsAxSkills = isRecipesIndex({ action, url }) &&
+                    !skillsPortalUrl &&
+                    (repo ? repo === AX_SKILLS_REPO : !commitHash);
+                if (readsAxSkills) {
+                    return {
+                        type: 'text',
+                        text: await fetchSourceContent(httpClient, AX_SKILLS_REPO, AX_SKILLS_INDEX_PATH, repo === AX_SKILLS_REPO ? commitHash : undefined)
+                    };
+                }
                 const fetchedContent = await fetchArticleContent(httpClient, url, 'article', true, skillsPortalUrl, repo, commitHash);
                 return {
                     type: 'text',
@@ -169,9 +189,6 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
         //     return '';
         //   });
         const baseContentsPromise = Promise.all(baseDocsWithoutRecipes.map(fetchDoc));
-        // Filtered lists still come from the portal. The full management index is
-        // authored alongside the recipes and is fetched like any other article,
-        // using its commit version when a PR override is configured.
         const skillsContentPromise = skillsTags?.length
             ? getSkillsByPortal(httpClient, {
                 portalId: REST_PORTAL_ID,
@@ -182,7 +199,9 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
                 console.error('[WixREADME] Failed to fetch skills by portal:', err);
                 return null;
             })
-            : fetchDoc({ action: 'include', url: RECIPES_INDEX_URL }).then((doc) => doc?.text ?? null);
+            : readmeRecipesIndexEnabled
+                ? fetchDoc({ action: 'include', url: RECIPES_INDEX_URL }).then((doc) => doc?.text ?? null)
+                : Promise.resolve(null);
         // Auto-inject site context. With no site targeted this is the account-wide
         // view: single-site accounts "just work", and accounts with more than the
         // cap show the first N sites plus a note to use GetSiteContext for the rest.
@@ -207,7 +226,7 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
         const recipesIntro = dedent `
           Reusable how-to guides for common ${isVisitorFlow ? 'Wix site visitor' : 'Wix management'} tasks, grouped by product area. Each recipe is a Wix docs article that bundles the right endpoints, request shapes, field names, and step ordering for one real-world use case.
 
-          Scan the index below and open any relevant article with \`ReadFullDocsArticle\`. If the article contains a code example that fits the user's intent — a **complete** example (not a truncated \`... N more lines ...\` snippet) that matches your exact case, same variant/shape — call the API directly. If the closest example is truncated or omits a field your case needs, do NOT call the API off it — continue discovery first: \`ReadFullDocsArticle\` for the complete example, or \`SearchWixAPISpec\` for the exact schema. On query and search methods an example proves only the fields and operators it uses; the endpoint's own declared list covers the rest. Otherwise (no fitting recipe, no usable code example, or persistent errors after retrying), fall back to docs discovery: \`SearchWixRESTDocumentation\` or \`BrowseWixRESTDocsMenu\` to find the right method, then \`SearchWixAPISpec\` for the exact schema.
+          Open the recipe that matches the task with \`ReadFullDocsArticle\` and follow it. When its example for a call matches your case (the same variant and shape), call from it; when it doesn't, or leaves out a field your case needs, read the method's schema with \`SearchWixAPISpec\` first. On query and search methods an example proves only the fields and operators it uses; the method's own declared list covers the rest. When no recipe fits, find the method with \`SearchWixRESTDocumentation\` or \`BrowseWixRESTDocsMenu\`, then \`SearchWixAPISpec\` for its schema.
         `;
         const recipesContents = skillsContent !== null
             ? [
@@ -217,9 +236,7 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
                     content: `${recipesIntro}\n\n${skillsContent}`
                 })
             ]
-            : await Promise.all(baseDocs
-                .filter((doc) => doc.url === RECIPES_INDEX_URL)
-                .map(fetchDoc));
+            : await Promise.all(recipesIndexDocs.map(fetchDoc));
         // Cross-recipe steering that applies to a family of recipes rather than
         // any single article; rendered right after the index. Gated on the note's
         // target family actually appearing in the rendered index — this also
@@ -244,7 +261,12 @@ export async function addGetToKnowTools({ server, disableTools = [], toolDescrip
                 .map((item) => item.text),
             ...(dynamicContext ? [dynamicContext] : [])
         ];
-        const text = parts.join('\n\n');
+        const joined = parts.join('\n\n');
+        // Mintlify docs: the README links docs pages on dev.wix.com; resolve
+        // them to their Mintlify pages, as the docs tools do.
+        const text = isMintlifyDocsSite(docsSite)
+            ? (await rewriteDocsLinks(joined, { label: 'readme WixREADME' })).text
+            : joined;
         return {
             content: [{ type: 'text', text }]
         };

package/build/dts/docs/guessed-url.d.ts

@@ -0,0 +1,41 @@
+export declare const slugWords: (slug: string) => Set<string>;
+/** Shared words over all words (Jaccard): 1 for the same words, 0 for none in common. */
+export declare function slugSimilarity(a: string, b: string): number;
+/** A file at least this close to the asked name, and the only one that close, is read in its place. */
+export declare const SKILL_FILE_MATCH = 0.5;
+export type SkillFileGuess = {
+    kind: 'file';
+    url: string;
+    path: string;
+} | {
+    kind: 'folder';
+    folder: string;
+    files: string[];
+    manifestUrl: string;
+};
+/**
+ * The closest file to a skills registry URL that 404'd, from the skill's manifest
+ * (`https://www.wix.com/skills/<skill>.manifest.json`, `{ base, files: [{ path }] }`).
+ * A file of the same name in another folder counts when it is the only one; a near name
+ * counts in the same folder only. Null when the URL is not a skill file or the manifest
+ * can't be read.
+ */
+export declare function closestSkillFile(url: string, manifest: {
+    base?: string;
+    files?: {
+        path: string;
+    }[];
+}, manifestUrl: string): SkillFileGuess | null;
+/** The manifest of the skill a registry URL is in, or null for a URL that names no skill. */
+export declare function skillManifestUrl(url: string): string | null;
+/** How far above a docs page the nearest menu is looked for. */
+export declare const MENU_WALK_UP_LEVELS = 3;
+/** The menus above a dev.wix.com docs URL, nearest first. */
+export declare function parentMenuUrls(url: string): string[];
+/** The menu's own entries (links under it) whose last segment is closest to the asked page, best first. */
+export declare function closestMenuLinks(menuText: string, menuUrl: string, askedUrl: string, limit?: number): string[];
+/** Below this, a menu's best entry is no answer, and its closest sub-menus are read too. */
+export declare const MENU_ENTRY_MATCH = 0.75;
+/** The menu's sub-menus worth reading for the asked page: its entries sharing a word with it, closest first. */
+export declare function subMenusToRead(menuText: string, menuUrl: string, askedUrl: string, limit?: number): string[];
+//# sourceMappingURL=guessed-url.d.ts.map

package/build/dts/docs/guessed-url.js

@@ -0,0 +1,185 @@
+/**
+ * What ReadFullDocsArticle offers for a docs or skills URL that 404s. Most of these are
+ * guessed: a method slug invented under a real resource, a recipe link "tidied" into a
+ * path that never existed, a skill file renamed since an agent's notes were written.
+ * Instead of a bare not-found, the agent gets the nearest thing that exists:
+ *
+ * - a skills registry file: the skill's manifest names every file, so a file whose name
+ *   is close to the asked one, in the same folder, is read in its place; otherwise the
+ *   folder's files are listed;
+ * - a dev.wix.com docs page: the nearest menu above it, with the links whose names are
+ *   closest to the asked page listed first.
+ */
+import { normalizeSkillsUrl } from './fetch-article.js';
+const SKILLS_BASE = 'https://www.wix.com/skills/';
+// Every host and path ReadFullDocsArticle accepts for the skills registry, as the
+// www.wix.com/skills/ URL whose manifest is next to it.
+const registryUrl = (url) => normalizeSkillsUrl(url).replace(/^https:\/\/(?:dev\.wix\.com(?:\/docs)?|www\.wix\.com\/velo\/reference)\/skills\//, SKILLS_BASE);
+const DOCS_BASE = 'https://dev.wix.com/docs/';
+// Words that say nothing about which file or page is meant.
+const FILLER = new Set([
+    '',
+    'md',
+    'a',
+    'an',
+    'the',
+    'and',
+    'or',
+    'of',
+    'to',
+    'wix',
+    's'
+]);
+export const slugWords = (slug) => new Set(slug
+    .toLowerCase()
+    .replace(/\.md$/, '')
+    .split(/[^a-z0-9]+/)
+    .filter((w) => !FILLER.has(w))
+    // A plural names the same thing: posts, post.
+    .map((w) => (w.length > 3 && w.endsWith('s') ? w.slice(0, -1) : w)));
+/** Shared words over all words (Jaccard): 1 for the same words, 0 for none in common. */
+export function slugSimilarity(a, b) {
+    const x = slugWords(a);
+    const y = slugWords(b);
+    if (x.size === 0 || y.size === 0)
+        return 0;
+    let shared = 0;
+    for (const w of x)
+        if (y.has(w))
+            shared++;
+    return shared / (x.size + y.size - shared);
+}
+const lastSegment = (path) => path.slice(path.lastIndexOf('/') + 1);
+const folderOf = (path) => path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '';
+/** A file at least this close to the asked name, and the only one that close, is read in its place. */
+export const SKILL_FILE_MATCH = 0.5;
+/**
+ * The closest file to a skills registry URL that 404'd, from the skill's manifest
+ * (`https://www.wix.com/skills/<skill>.manifest.json`, `{ base, files: [{ path }] }`).
+ * A file of the same name in another folder counts when it is the only one; a near name
+ * counts in the same folder only. Null when the URL is not a skill file or the manifest
+ * can't be read.
+ */
+export function closestSkillFile(url, manifest, manifestUrl) {
+    const normalized = registryUrl(url).replace(/[?#].*$/, '');
+    if (!normalized.startsWith(SKILLS_BASE))
+        return null;
+    const [, ...rest] = normalized.slice(SKILLS_BASE.length).split('/');
+    const asked = rest.join('/');
+    const paths = (manifest.files ?? []).map((f) => f.path);
+    if (!asked || paths.length === 0)
+        return null;
+    const base = manifest.base ?? manifestUrl.replace(/\.manifest\.json$/, '/');
+    const name = lastSegment(asked);
+    const folder = folderOf(asked);
+    const sameName = paths.filter((p) => lastSegment(p) === name);
+    if (sameName.length === 1) {
+        return { kind: 'file', path: sameName[0], url: base + sameName[0] };
+    }
+    const ranked = paths
+        .filter((p) => folderOf(p) === folder)
+        .map((p) => ({ p, score: slugSimilarity(lastSegment(p), name) }))
+        .sort((a, b) => b.score - a.score);
+    const [best, next] = ranked;
+    if (best &&
+        best.score >= SKILL_FILE_MATCH &&
+        best.score > (next?.score ?? 0)) {
+        return { kind: 'file', path: best.p, url: base + best.p };
+    }
+    if (ranked.length > 0) {
+        return {
+            kind: 'folder',
+            folder,
+            files: ranked.map((r) => base + r.p),
+            manifestUrl
+        };
+    }
+    // The folder doesn't exist either: the skill's top-level folders and files.
+    const top = [...new Set(paths.map((p) => p.split('/')[0]))].sort();
+    return {
+        kind: 'folder',
+        folder: '',
+        files: top.map((t) => base + t),
+        manifestUrl
+    };
+}
+/** The manifest of the skill a registry URL is in, or null for a URL that names no skill. */
+export function skillManifestUrl(url) {
+    const normalized = registryUrl(url);
+    if (!normalized.startsWith(SKILLS_BASE))
+        return null;
+    const skill = normalized.slice(SKILLS_BASE.length).split(/[/?#]/)[0];
+    return skill ? `${SKILLS_BASE}${skill}.manifest.json` : null;
+}
+/** How far above a docs page the nearest menu is looked for. */
+export const MENU_WALK_UP_LEVELS = 3;
+// A menu this close to the root (`/docs/velo`, `/docs/api-reference/crm`) lists whole
+// products, which says nothing about the page that was asked for.
+const MIN_MENU_SEGMENTS = 3;
+/** The menus above a dev.wix.com docs URL, nearest first. */
+export function parentMenuUrls(url) {
+    const clean = url.replace(/[?#].*$/, '').replace(/\/+$/, '');
+    if (!clean.startsWith(DOCS_BASE))
+        return [];
+    const segments = clean.slice(DOCS_BASE.length).split('/');
+    const out = [];
+    for (let up = 1; up <= MENU_WALK_UP_LEVELS; up++) {
+        const kept = segments.length - up;
+        if (kept < MIN_MENU_SEGMENTS)
+            break;
+        out.push(DOCS_BASE + segments.slice(0, kept).join('/'));
+    }
+    return out;
+}
+/** The menu's own entries (links under it) whose last segment is closest to the asked page, best first. */
+export function closestMenuLinks(menuText, menuUrl, askedUrl, limit = 3) {
+    const asked = lastSegment(askedUrl.replace(/[?#].*$/, '').replace(/\/+$/, ''));
+    const under = `${menuUrl.replace(/\/+$/, '')}/`;
+    const links = [
+        ...new Set(menuText.match(/https:\/\/dev\.wix\.com\/docs\/[^\s)\]>"'`]+/g) ?? [])
+    ].filter((l) => l.startsWith(under));
+    return links
+        .map((l) => ({
+        l,
+        score: slugSimilarity(lastSegment(l.replace(/\.md$/, '')), asked)
+    }))
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map((r) => r.l);
+}
+const SMALL_MENU = 3;
+/** Below this, a menu's best entry is no answer, and its closest sub-menus are read too. */
+export const MENU_ENTRY_MATCH = 0.75;
+/** The menu's sub-menus worth reading for the asked page: its entries sharing a word with it, closest first. */
+export function subMenusToRead(menuText, menuUrl, askedUrl, limit = 2) {
+    const asked = lastSegment(askedUrl.replace(/[?#].*$/, '').replace(/\/+$/, ''));
+    const under = `${menuUrl.replace(/\/+$/, '')}/`;
+    // A method entry (`- [Create Order](…) _(POST)_`) is a page, not a menu.
+    const methods = new Set([
+        ...menuText.matchAll(/\]\((https:\/\/dev\.wix\.com\/docs\/[^)\s]+)\)\s*_\((?:GET|POST|PUT|PATCH|DELETE)\)_/g)
+    ].map((m) => m[1]));
+    // Direct children only: the legacy menu text also lists pages nested further down.
+    const entries = [
+        ...new Set(menuText.match(/https:\/\/dev\.wix\.com\/docs\/[^\s)\]>"'`]+/g) ?? [])
+    ].filter((l) => l.startsWith(under) &&
+        !l.slice(under.length).replace(/\.md$/, '').includes('/') &&
+        !methods.has(l));
+    const scored = entries
+        .map((l) => ({
+        l,
+        score: slugSimilarity(lastSegment(l.replace(/\.md$/, '')), asked)
+    }))
+        .sort((a, b) => b.score - a.score);
+    if (scored.some((s) => s.score >= MENU_ENTRY_MATCH))
+        return [];
+    // A menu of a few entries is read whole: none may share a word (catalog-v1 holds
+    // catalog and inventory; products sit under catalog).
+    if (entries.length <= SMALL_MENU)
+        return entries;
+    return scored
+        .filter((s) => s.score > 0)
+        .slice(0, limit)
+        .map((s) => s.l);
+}
+//# sourceMappingURL=guessed-url.js.map

package/build/dts/docs/mintlify-docs.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Mintlify docs, `mintlify-links` mode (wix-private/docs:
+ * documentation/mintlify-migration/tasks/mcp-pipeline.md).
+ *
+ * The KBs and every backend stay as they are. With `docsSite: 'mintlify-links'`,
+ * the docs tools resolve each dev.wix.com docs link in their output to its page
+ * on the Mintlify site, and ReadFullDocsArticle reads pages from Mintlify's
+ * `.md`. Off unless a caller passes the option.
+ */
+export declare const MINTLIFY_LINKS_DOCS_SITE = "mintlify-links";
+/** Stage 2: the same, with search on the Mintlify KBs indexed from the Mintlify site. */
+export declare const MINTLIFY_DOCS_SITE = "mintlify";
+export type DocsSite = typeof MINTLIFY_LINKS_DOCS_SITE | typeof MINTLIFY_DOCS_SITE;
+export declare const MINTLIFY_HOST = "https://wix-internal.mintlify.site";
+export declare const MAX_CHECK_ENTRIES = 5000;
+export declare function isMintlifyDocsSite(docsSite: string | undefined): boolean;
+/** The Mintlify document types a search tool uses in stage 2, or undefined to search as today. */
+export declare function mintlifyDocumentTypes(docsSite: string | undefined, toolName: string): string[] | undefined;
+export declare function isMintlifyUrl(url: string): boolean;
+/** The URL prefixes the docs tools accept in Mintlify mode, besides dev.wix.com. */
+export declare const MINTLIFY_URL_PREFIXES: string[];
+export interface MintlifyCandidate {
+    /** Canonical Mintlify page URL: host + path, no query, anchor or `.md`. */
+    url: string;
+    path: string;
+    /** `sdk` when the source link asked for the SDK view (`?apiView=SDK`). */
+    flavour: 'rest' | 'sdk';
+}
+/**
+ * Maps a dev.wix.com docs URL, or a Mintlify URL on any alias host, to its
+ * Mintlify page by rule: drop `/docs`, map the portal slug to its tab, drop
+ * the query, the anchor and `.md`. Returns null for anything else.
+ */
+export declare function toMintlifyCandidate(rawUrl: string): MintlifyCandidate | null;
+/**
+ * Maps a Mintlify URL back to its dev.wix.com docs URL, keeping `?apiView=SDK`.
+ * For the REST portal the paths are the same, so the backends that only know
+ * dev.wix.com (ingvar, the docs menu) can serve it.
+ */
+export declare function toDevWixUrl(rawUrl: string): string;
+export type ResolveOutcome = 'identity' | 'redirect' | 'missing' | 'other-portal' | 'not-docs' | 'error';
+export interface ResolvedLink {
+    outcome: ResolveOutcome;
+    /** The URL to hand out: the Mintlify page when resolved, else the input. */
+    url: string;
+}
+interface PageCheck {
+    outcome: 'identity' | 'redirect' | 'missing' | 'error';
+    /** Final page path on the Mintlify site, when the page exists. */
+    path?: string;
+}
+/** For tests. */
+export declare function mintlifyCheckCacheSize(): number;
+/** For tests. */
+export declare function clearMintlifyCheckCache(): void;
+/**
+ * Asks the Mintlify site whether a page exists, following its own redirects
+ * (moves, and containers that send you to their first page) without
+ * following them blindly: a page is a 200 at the end of at most 3 hops.
+ */
+export declare function checkMintlifyPage(path: string): Promise<PageCheck>;
+/**
+ * Resolves one docs link to its Mintlify page. With `verify: false` the
+ * mapping is by rule only, which suits menu links (the menu and the Mintlify
+ * navigation come from the same Portal Service tree).
+ */
+export declare function resolveDocsLink(rawUrl: string, { verify }?: {
+    verify?: boolean;
+}): Promise<ResolvedLink>;
+/**
+ * Maps every Mintlify page link in `text` back to its dev.wix.com docs URL, keeping
+ * `?apiView=SDK` and the anchor. Run before {@link rewriteDocsLinks} on text whose
+ * Mintlify links came by rule rather than from a checked page (SearchWixAPISpec's
+ * index), so a page the site doesn't have ends up on dev.wix.com, not a dead link.
+ */
+export declare function toDevWixHostText(text: string): string;
+export interface RewriteStats {
+    links: number;
+    byOutcome: Partial<Record<ResolveOutcome, number>>;
+    misses: string[];
+}
+/**
+ * Rewrites every docs link in `text` to its Mintlify page. Links with no
+ * Mintlify page stay as they are, so the agent can still read them through
+ * today's backends. Logs one coverage line per call.
+ */
+export declare function rewriteDocsLinks(text: string, { verify, label }?: {
+    verify?: boolean;
+    label?: string;
+}): Promise<{
+    text: string;
+    stats: RewriteStats;
+}>;
+/**
+ * Light cleanup of a method page's .md: drop inlined snippet source, and keep
+ * only the tab the reader asked for (REST, or SDK for `?apiView=SDK`). A
+ * method page carries both, which roughly doubles its size. Pages without
+ * exactly one REST and one SDK tab are left as they are.
+ */
+export declare function cleanMintlifyMarkdown(markdown: string, flavour: 'rest' | 'sdk'): string;
+/**
+ * Tool and parameter descriptions with their docs URLs on the Mintlify host. The
+ * model copies the examples' host when it cites a page, so with dev.wix.com in
+ * the descriptions it rewrites Mintlify links back to dev.wix.com.
+ */
+export declare function toMintlifyHostText(text: string): string;
+/**
+ * Mintlify's .md links the site's own pages by path (`[Order Object](/api-reference/…)`).
+ * Make them absolute, so the model doesn't have to guess the host (it picks dev.wix.com).
+ */
+export declare function absolutizeSiteLinks(markdown: string): string;
+/**
+ * Reads a page from the Mintlify site as Markdown. Returns null when the site
+ * has no page for the URL, so the caller can fall back to today's backend.
+ */
+export declare function readMintlifyMarkdown(rawUrl: string): Promise<{
+    url: string;
+    markdown: string;
+} | null>;
+export {};
+//# sourceMappingURL=mintlify-docs.d.ts.map