ifandco-mcp 1.0.1 → 1.0.2

package/README.md

@@ -10,7 +10,29 @@ Query the IF & Co. catalog (ifandco.com, NYC): search custom pendants, chains, r
 - `price_overview` — Ask-price distribution (min/p25/median/p75/max).
 - `find_deals` — Available products priced below the median.
 - `list_categories` — Product-type counts in the catalog sample.
+- `list_collections` — Collections with handle, product count and URL, longest first.
+- `collection_products` — Every product in one collection with live price and stock, sortable.
+- `restock_check` — Stock and price for specific product handles: what is buyable right now and which options are left.
 
 ## Source
 
 [ifandco-mcp](https://github.com/mrfentmen/premium-mcps/tree/main/servers/ifandco-mcp)
+
+<!-- paywall -->
+## Premium tools
+
+These tools need a license key:
+
+* `material_census`
+* `personalisation_census`
+
+Buy a key at https://mcp-marketplace.io/server/io-github-mrfentmen-ifandco-mcp and set it in your MCP client config:
+
+```json
+"env": { "MCP_LICENSE_KEY": "mcp_live_..." }
+```
+
+The key is checked against MCP Marketplace, cached for 24 hours, and keeps
+working offline once one check has succeeded. Every other tool on this server
+stays free.
+<!-- /paywall -->

package/dist/api.d.ts

@@ -8,3 +8,16 @@ export declare function getProduct(handle: string): Promise<string>;
 export declare function priceOverview(limit?: string): Promise<string>;
 export declare function findDeals(limit?: string, sample?: string): Promise<string>;
 export declare function listCategories(): Promise<string>;
+export declare function listCollections(limit?: string): Promise<string>;
+export declare function collectionProducts(handle: string, limit?: string, sort?: string): Promise<string>;
+export declare function restockCheck(handles: string): Promise<string>;
+/** What the catalogue is actually made of, counted from the titles, tags and variant names. */
+export declare function materialCensus(args: {
+    sample?: string;
+    limit?: string;
+}): Promise<string>;
+/** The personalisation the house offers, which the product tools only reveal one listing at a time. */
+export declare function personalisationCensus(args: {
+    sample?: string;
+    limit?: string;
+}): Promise<string>;

package/dist/api.js

@@ -18,7 +18,7 @@ function pretty(data) {
 async function getJson(url) {
     let res;
     try {
-        res = await fetch(url, { headers: { ...UA } });
+        res = await fetch(url, { signal: AbortSignal.timeout(30000), headers: { ...UA } });
     }
     catch (e) {
         throw new IfAndCoError(`Network error: ${e.message}`);
@@ -88,7 +88,7 @@ export async function searchProducts(query, limit, maxPrice, productType) {
         if (out.length >= n)
             break;
     }
-    return pretty({ store: "IF & Co.", query, count: out.length, listings: out });
+    return pretty({ store: "IF & Co.", query, returned: out.length, truncated: out.length >= n, listings: out });
 }
 export async function listNewest(limit, page, productType) {
     const n = Math.min(Number(limit ?? 20) || 20, 50);
@@ -100,7 +100,7 @@ export async function listNewest(limit, page, productType) {
             out.push(sl);
     }
     out.sort((a, b) => String(b.published_at ?? "").localeCompare(String(a.published_at ?? "")));
-    return pretty({ store: "IF & Co.", page: pg, count: out.length, listings: out.slice(0, n) });
+    return pretty({ store: "IF & Co.", page: pg, matched_on_page: out.length, returned: Math.min(out.length, n), listings: out.slice(0, n) });
 }
 function parseParts(title) {
     return String(title ?? "").split("/").map((s) => s.trim()).filter(Boolean);
@@ -126,9 +126,12 @@ export async function getProduct(handle) {
 export async function priceOverview(limit) {
     const n = Math.min(Number(limit ?? 200) || 200, 500);
     const prices = [];
+    let unpriced = 0;
     for (const p of await sampleCatalog(n, [1, 2, 3])) {
         const sl = slim(p);
-        if (sl.price_usd !== null)
+        if (sl.price_usd === null || sl.price_usd <= 0)
+            unpriced += 1;
+        else
             prices.push(sl.price_usd);
     }
     if (!prices.length)
@@ -136,7 +139,7 @@ export async function priceOverview(limit) {
     const a = [...prices].sort((x, y) => x - y);
     const mid = a.length % 2 ? a[(a.length - 1) / 2] : (a[a.length / 2 - 1] + a[a.length / 2]) / 2;
     return pretty({
-        store: "IF & Co.", currency: "USD", sample: a.length,
+        store: "IF & Co.", currency: "USD", unpriced, sample: a.length,
         min: a[0], p25: a[Math.floor(a.length * 0.25)], median: mid,
         p75: a[Math.floor(a.length * 0.75)], max: a[a.length - 1],
         note: "Storefront asking prices. Not affiliated with IF & Co..",
@@ -148,7 +151,7 @@ export async function findDeals(limit, sample) {
     const all = [];
     for (const p of await sampleCatalog(per, [1, 2, 3])) {
         const sl = slim(p);
-        if (sl.price_usd !== null && sl.available)
+        if (sl.price_usd !== null && sl.price_usd > 0 && sl.available)
             all.push(sl);
     }
     if (!all.length)
@@ -161,7 +164,7 @@ export async function findDeals(limit, sample) {
         .map((s) => ({ ...s, vs_median_usd: Math.round((s.price_usd - median) * 100) / 100, vs_median_pct: Math.round(((s.price_usd - median) / median) * 1000) / 10 }))
         .sort((a, b) => a.vs_median_pct - b.vs_median_pct);
     return pretty({
-        store: "IF & Co.", sample: all.length, median_usd: median, count: Math.min(deals.length, n),
+        store: "IF & Co.", sample: all.length, median_usd: median, matched: deals.length, returned: Math.min(deals.length, n),
         deals: deals.slice(0, n),
         note: "Below-median asks, not appraisals. Not affiliated with IF & Co..",
     });
@@ -174,3 +177,192 @@ export async function listCategories() {
     }
     return pretty({ store: "IF & Co.", sample: Object.values(counts).reduce((a, b) => a + b, 0), categories: counts });
 }
+// ---- batch-4 tools: collections and stock (2026-09-27) ----
+const COLLECTIONS = "https://ifandco.com/collections";
+export async function listCollections(limit) {
+    const n = Math.min(Number(limit ?? 40) || 40, 250);
+    const data = await getJson(`${COLLECTIONS}.json`);
+    const rows = (Array.isArray(data.collections) ? data.collections : [])
+        .filter((c) => typeof c?.handle === "string" && c.handle)
+        .map((c) => ({
+        title: String(c.title ?? c.handle),
+        handle: c.handle,
+        products_count: typeof c.products_count === "number" ? c.products_count : null,
+        url: `${COLLECTIONS}/${c.handle}`,
+    }))
+        .sort((a, b) => (b.products_count ?? 0) - (a.products_count ?? 0));
+    if (!rows.length)
+        throw new IfAndCoError("The store returned no collections.");
+    return pretty({
+        store: "IF & Co.", collections: rows.length, returned: Math.min(rows.length, n),
+        listings: rows.slice(0, n),
+        note: "Longest collections first; call collection_products with a handle.",
+    });
+}
+export async function collectionProducts(handle, limit, sort) {
+    const clean = String(handle ?? "").trim();
+    if (!clean)
+        throw new IfAndCoError("Provide a collection handle - call list_collections first.");
+    const n = Math.min(Number(limit ?? 20) || 20, 50);
+    const data = await getJson(`${COLLECTIONS}/${encodeURIComponent(clean)}/products.json?limit=250`);
+    const items = Array.isArray(data.products) ? data.products : [];
+    if (!items.length)
+        throw new IfAndCoError(`Collection "${clean}" is empty or unknown - call list_collections.`);
+    const rows = items.map((p) => slim(p));
+    const order = String(sort ?? "featured").toLowerCase();
+    if (order === "price_low")
+        rows.sort((a, b) => (a.price_usd ?? Infinity) - (b.price_usd ?? Infinity));
+    else if (order === "price_high")
+        rows.sort((a, b) => (b.price_usd ?? -Infinity) - (a.price_usd ?? -Infinity));
+    else if (order === "newest")
+        rows.sort((a, b) => String(b.published_at ?? "").localeCompare(String(a.published_at ?? "")));
+    const inStock = rows.filter((r) => r.available).length;
+    const priced = rows.map((r) => r.price_usd).filter((p) => p !== null);
+    return pretty({
+        store: "IF & Co.", collection: clean, sort: order, products: rows.length, in_stock: inStock,
+        price_usd: priced.length ? { min: Math.min(...priced), max: Math.max(...priced) } : null,
+        returned: Math.min(rows.length, n), listings: rows.slice(0, n),
+    });
+}
+export async function restockCheck(handles) {
+    const list = String(handles ?? "")
+        .split(/[,\s]+/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .slice(0, 10);
+    if (!list.length)
+        throw new IfAndCoError("Provide up to 10 product handles, comma separated.");
+    const rows = [];
+    const problems = [];
+    // One handle at a time: the storefront rejects bursts of .js requests.
+    for (const h of list) {
+        try {
+            const p = await getJson(`${PRODUCT_BASE}/${encodeURIComponent(h)}.js`);
+            const variants = Array.isArray(p.variants) ? p.variants : [];
+            const live = variants.filter((v) => v.available === true);
+            const prices = variants.map((v) => Math.round(Number(v.price)) / 100).filter((n) => Number.isFinite(n) && n > 0);
+            rows.push({
+                handle: h,
+                title: p.title ?? h,
+                in_stock: live.length > 0,
+                variants: variants.length,
+                variants_in_stock: live.length,
+                min_price_usd: prices.length ? Math.min(...prices) : null,
+                options_in_stock: live.slice(0, 6).map((v) => String(v.title ?? "").trim()).filter(Boolean),
+                url: `${PRODUCT_BASE}/${h}`,
+            });
+        }
+        catch (e) {
+            problems.push(`${h}: ${errorMessage(e)}`);
+        }
+    }
+    if (!rows.length)
+        throw new IfAndCoError(`No handle could be read. ${problems.join("; ")}`);
+    return pretty({
+        store: "IF & Co.", checked: rows.length, in_stock: rows.filter((r) => r.in_stock).length,
+        listings: rows, problems,
+        note: "Availability is the storefront's own flag, read at request time.",
+    });
+}
+// ---- muxG tools:
+const IFCO_PAGES = [1, 2, 3, 4];
+// The catalogue states its material in the title and in the variant titles,
+// so a census over that text is a census over what the house actually sells.
+const MATERIALS = [
+    { key: "14k-gold", label: "14k gold", pattern: /\b14k\b|\b14 carat\b/i },
+    { key: "18k-gold", label: "18k gold", pattern: /\b18k\b|\b18 carat\b/i },
+    { key: "solid-gold", label: "solid gold (unqualified karat)", pattern: /\bsolid gold\b/i },
+    { key: "sterling", label: "sterling silver / 925", pattern: /\b925\b|\bsterling\b/i },
+    { key: "platinum", label: "platinum", pattern: /\bplatinum\b|\bplat\b/i },
+    { key: "vermeil", label: "vermeil", pattern: /\bvermeil\b/i },
+    { key: "gold-filled", label: "gold filled", pattern: /\bgold[- ]filled\b/i },
+    { key: "diamond", label: "diamond", pattern: /\bdiamond(s)?\b/i },
+    { key: "lab-diamond", label: "lab grown or lab created diamond", pattern: /\blab[- ](grown|created)\b/i },
+    { key: "sapphire", label: "sapphire", pattern: /\bsapphire(s)?\b/i },
+    { key: "emerald", label: "emerald", pattern: /\bemerald(s)?\b/i },
+    { key: "ruby", label: "ruby", pattern: /\bruby\b|\brubies\b/i },
+    { key: "pearl", label: "pearl", pattern: /\bpearl(s)?\b/i },
+    { key: "morganite", label: "morganite", pattern: /\bmorganite\b/i },
+    { key: "moissanite", label: "moissanite", pattern: /\bmoissanite\b/i },
+    { key: "turquoise", label: "turquoise", pattern: /\bturquoise\b/i },
+    { key: "onyx", label: "onyx", pattern: /\bonyx\b/i },
+];
+const PERSONALISATION = [
+    { key: "engraving", label: "engraving mentioned", pattern: /\bengrav/i },
+    { key: "initial", label: "initial or letter", pattern: /\binitial(s)?\b|\bletter(s)?\b|\bmonogram/i },
+    { key: "birthstone", label: "birthstone", pattern: /\bbirthstone\b/i },
+    { key: "custom-size", label: "custom or made to order sizing", pattern: /\bmade to order\b|\bcustom size\b|\bsize guide\b/i },
+    { key: "gift-box", label: "gift packaging", pattern: /\bgift box\b|\bgift packaging\b/i },
+    { key: "stackable", label: "stackable", pattern: /\bstackable\b/i },
+    { key: "hypoallergenic", label: "hypoallergenic", pattern: /\bhypoallergenic\b|\bnickel[- ]free\b/i },
+    { key: "waterproof", label: "waterproof", pattern: /\bwaterproof\b|\bwater[- ]resistant\b/i },
+];
+const stripHtml = (html) => String(html ?? "").replace(/<[^>]+>/g, " ").replace(/&[a-z]+;/gi, " ").replace(/\s+/g, " ").trim();
+const ifcoMedian = (values) => {
+    if (!values.length)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+};
+function censusOver(products, terms, textOf) {
+    const out = terms.map((term) => ({ label: term.label, products: new Set(), prices: [] }));
+    for (const product of products) {
+        const handle = String(product.handle ?? product.id ?? "?");
+        const text = textOf(product);
+        for (const [i, term] of terms.entries()) {
+            if (!term.pattern.test(text))
+                continue;
+            out[i].products.add(handle);
+            const variantPrices = (Array.isArray(product.variants) ? product.variants : [])
+                .map((variant) => Math.round(Number(variant?.price)))
+                .filter((price) => Number.isFinite(price) && price > 0);
+            const top = Math.round(Number(product.price));
+            if (variantPrices.length)
+                out[i].prices.push(...variantPrices);
+            else if (Number.isFinite(top) && top > 0)
+                out[i].prices.push(top);
+        }
+    }
+    return out;
+}
+const censusLines = (rows, total, unit, n) => {
+    const lines = [`${total} product(s) scanned, matches are per listing and a listing can carry several`, ""];
+    for (const row of rows.filter((entry) => entry.products.size).sort((a, b) => b.products.size - a.products.size).slice(0, n)) {
+        const median = ifcoMedian(row.prices);
+        const share = ((row.products.size / Math.max(total, 1)) * 100).toFixed(1);
+        lines.push(`  ${row.label}: ${row.products.size} listing(s) (${share}%) · ${row.prices.length} priced ${unit} · median ${median === null ? "not reported" : `$${median.toLocaleString("en-US")}`}`);
+    }
+    const missing = rows.filter((entry) => !entry.products.size).map((entry) => entry.label);
+    if (missing.length)
+        lines.push(`  not found in the sample: ${missing.join(", ")}`);
+    return lines;
+};
+/** What the catalogue is actually made of, counted from the titles, tags and variant names. */
+export async function materialCensus(args) {
+    const max = Math.min(Math.max(Number(args.sample ?? 400) || 400, 20), 2000);
+    const n = Math.min(Math.max(Number(args.limit ?? 16) || 16, 1), 30);
+    const pages = IFCO_PAGES.slice(0, Math.max(1, Math.ceil(max / 250)));
+    const products = await sampleCatalog(max, pages);
+    if (!products.length)
+        throw new Error("The catalogue returned no products.");
+    const rows = censusOver(products, MATERIALS, (product) => [String(product.title ?? ""), (Array.isArray(product.tags) ? product.tags.join(" ") : ""), stripHtml(product.body_html)].join(" "));
+    return [
+        `Material and stone census for the IF & Co. catalogue: ${products.length} listing(s) sampled`,
+        ...censusLines(rows, products.length, "variant(s)", n),
+    ].join("\n");
+}
+/** The personalisation the house offers, which the product tools only reveal one listing at a time. */
+export async function personalisationCensus(args) {
+    const max = Math.min(Math.max(Number(args.sample ?? 400) || 400, 20), 2000);
+    const n = Math.min(Math.max(Number(args.limit ?? 10) || 10, 1), 20);
+    const pages = IFCO_PAGES.slice(0, Math.max(1, Math.ceil(max / 250)));
+    const products = await sampleCatalog(max, pages);
+    if (!products.length)
+        throw new Error("The catalogue returned no products.");
+    const rows = censusOver(products, PERSONALISATION, (product) => [String(product.title ?? ""), (Array.isArray(product.tags) ? product.tags.join(" ") : ""), stripHtml(product.body_html)].join(" "));
+    return [
+        `Personalisation census for the IF & Co. catalogue: ${products.length} listing(s) sampled`,
+        ...censusLines(rows, products.length, "variant(s)", n),
+    ].join("\n");
+}

package/dist/license.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns null when the caller may run the tool, or a short message telling
+ * them how to get a key.
+ *
+ * A good key is remembered for an hour, so a busy session does not hit the
+ * license server on every call and keeps working through a brief outage.
+ */
+export declare function premiumRequired(tool: string): Promise<string | null>;

package/dist/license.js

@@ -0,0 +1,79 @@
+// Premium tools on this server need a license key bought from MCP Marketplace.
+// Buyers put the key in their MCP client config as MCP_LICENSE_KEY. Every tool
+// that is not listed in PREMIUM keeps working without a key.
+const SLUG = "ifandco-mcp";
+// Tools that need a key. Everything else is free.
+const PREMIUM = new Set([
+    "material_census",
+    "personalisation_census",
+]);
+const BUY_URL = `https://mcp-marketplace.io/server/io-github-mrfentmen-${SLUG}`;
+// The license check calls the marketplace's verify endpoint directly instead of
+// using @mcp_marketplace/license. That SDK sends no `apikey` header, so every
+// check it makes is rejected by Supabase before it reaches the function. The
+// publishable key below is public by design - it ships in mcp-marketplace.io's
+// own JavaScript and only ever reaches their licence check.
+const DEFAULT_VERIFY_URL = "https://virupvwhtkpkjsiskckg.supabase.co/functions/v1/verify-key";
+const PUBLISHABLE_KEY = "sb_publishable_BuqlW96Ke8C_zzJG-LQv1Q_YHi_r_4h";
+const OK_CACHE_MS = 60 * 60 * 1000;
+const BAD_CACHE_MS = 60 * 1000;
+const seen = new Map();
+const REASONS = {
+    missing_key: "no key is set",
+    invalid_format: "that key is not a valid MCP Marketplace key",
+    not_found: "that key was not found",
+    revoked: "that key has been revoked",
+    rotated: "that key was rotated, use your new one",
+    expired: "that key has expired, renew it",
+    rate_limited: "there were too many checks just now, try again shortly",
+    network_error: "the license server could not be reached",
+};
+function blocked(tool, reason) {
+    const why = REASONS[reason] ?? `the license server answered "${reason}"`;
+    return `"${tool}" needs a license key, but ${why}. ` +
+        `Set MCP_LICENSE_KEY in your MCP client config. Get a key: ${BUY_URL}`;
+}
+async function verify(key) {
+    const res = await fetch(process.env.MCP_LICENSE_VERIFY_URL || DEFAULT_VERIFY_URL, {
+        method: "POST",
+        headers: {
+            apikey: PUBLISHABLE_KEY,
+            Authorization: `Bearer ${PUBLISHABLE_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ key, slug: SLUG }),
+        // an unusable key answers 400 with a JSON body, so read the body either way
+        signal: AbortSignal.timeout(15000),
+    });
+    const data = (await res.json());
+    if (typeof data?.valid !== "boolean")
+        return { valid: false, reason: "unexpected_response" };
+    return data;
+}
+/**
+ * Returns null when the caller may run the tool, or a short message telling
+ * them how to get a key.
+ *
+ * A good key is remembered for an hour, so a busy session does not hit the
+ * license server on every call and keeps working through a brief outage.
+ */
+export async function premiumRequired(tool) {
+    if (!PREMIUM.has(tool))
+        return null;
+    const key = process.env.MCP_LICENSE_KEY;
+    if (!key)
+        return blocked(tool, "missing_key");
+    const hit = seen.get(key);
+    if (hit && Date.now() - hit.at < (hit.valid ? OK_CACHE_MS : BAD_CACHE_MS)) {
+        return hit.valid ? null : blocked(tool, hit.reason ?? "invalid");
+    }
+    let result;
+    try {
+        result = await verify(key);
+    }
+    catch {
+        result = { valid: false, reason: "network_error" };
+    }
+    seen.set(key, { ...result, at: Date.now() });
+    return result.valid ? null : blocked(tool, result.reason ?? "invalid");
+}

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { errorMessage, searchProducts, listNewest, getProduct, priceOverview, findDeals, listCategories, } from "./api.js";
+import { errorMessage, searchProducts, listNewest, getProduct, priceOverview, findDeals, listCategories, listCollections, collectionProducts, restockCheck, materialCensus, personalisationCensus } from "./api.js";
+import { premiumRequired } from "./license.js";
 const text = (t) => ({ content: [{ type: "text", text: t }] });
 const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
 const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -13,7 +14,7 @@ export function createServer() {
         title: "Search products",
         description: "Keyword search across the catalog.",
         inputSchema: z.object({
-            query: z.string().describe("Keyword, e.g. pendant, cuban link, rolex."),
+            query: z.string().describe("Keyword, e.g. pendant, tennis chain, ring."),
             limit: z.string().describe("Max results (default 10, max 25).").optional(),
             max_price: z.string().describe("Max USD price.").optional(),
             product_type: z.string().describe("Filter by type.").optional()
@@ -103,5 +104,88 @@ export function createServer() {
             return textError(errorMessage(e));
         }
     });
+    server.registerTool("list_collections", {
+        title: "List collections",
+        description: "Collections with handle, product count and URL, longest first.",
+        inputSchema: z.object({
+            limit: z.string().describe("Max collections (default 40, max 250).").optional()
+        }),
+        annotations: READ_ONLY,
+    }, async ({ limit }) => {
+        try {
+            return text(await listCollections(limit));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("collection_products", {
+        title: "Collection products",
+        description: "Every product in one collection with live price and stock, sortable.",
+        inputSchema: z.object({
+            handle: z.string().describe("Collection handle from list_collections, e.g. balms."),
+            limit: z.string().describe("Max results (default 20, max 50).").optional(),
+            sort: z.string().describe("featured, price_low, price_high or newest.").optional()
+        }),
+        annotations: READ_ONLY,
+    }, async ({ handle, limit, sort }) => {
+        try {
+            return text(await collectionProducts(handle, limit, sort));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("restock_check", {
+        title: "Restock check",
+        description: "Stock and price for specific product handles: what is buyable right now and which options are left.",
+        inputSchema: z.object({
+            handles: z.string().describe("Up to 10 product handles, comma separated.")
+        }),
+        annotations: READ_ONLY,
+    }, async ({ handles }) => {
+        try {
+            return text(await restockCheck(handles));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("material_census", {
+        title: "Material census",
+        description: "What the catalogue is actually made of: how many listings mention each metal or stone, the share of the sample, and the median price of the variants that carry it. Counted from real titles, tags and descriptions.",
+        inputSchema: z.object({ sample: z.string().describe("How many products to sample (default 400, max 2000).").optional(), limit: z.string().describe("How many materials to print (default 16, max 30).").optional() }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        // ---- paywall: material_census ----
+        const paywallMessage = await premiumRequired("material_census");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await materialCensus(args));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("personalisation_census", {
+        title: "Personalisation census",
+        description: "The personalisation the catalogue offers - engraving, initials, birthstones, made-to-order sizing, gift packaging, stackability, hypoallergenic, waterproof - with the share of listings that mention each.",
+        inputSchema: z.object({ sample: z.string().describe("How many products to sample (default 400, max 2000).").optional(), limit: z.string().describe("How many personalisation types to print (default 10, max 20).").optional() }),
+        annotations: READ_ONLY,
+    }, async (args) => {
+        // ---- paywall: personalisation_census ----
+        const paywallMessage = await premiumRequired("personalisation_census");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await personalisationCensus(args));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
     return server;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ifandco-mcp",
-  "version": "1.0.1",
-  "description": "IF & Co. jewelry: search, products, prices. Keyless.",
+  "version": "1.0.2",
+  "description": "Query the IF & Co. catalog: search custom pendants, chains, rings and bracelets, newest arrivals, enriched product details, price stats, below-median deals.",
   "type": "module",
   "mcpName": "io.github.mrfentmen/ifandco-mcp",
   "repository": {