@nooticr/mcp 1.26.36 → 1.26.37

package/README.md

@@ -145,6 +145,9 @@ a `scanId` for the rest.
 | `scan_amazon_category` | 3 per listing collected (30 by default) | The category, collected: listings with prices, star histograms, Amazon's own review-aspect counts and the review text itself, plus the arithmetic over them — price spread, rating spread, which aspects recur across how many brands, and the share of each listing's ratings sitting at 1-2 stars, read from the histogram rather than from the handful of reviews a scrape returns. Pass `query` to search the category, `asins` to pin the competitors a customer named, or both; named competitors keep their place at the front. Because the price is set by an argument, it confirms the total before spending it. |
 | `amazon_scan_status` | free | Picks a running collection back up by `scanId` — the listings collected since, with the same rollup. Free: it is the poll `scan_amazon_category` asked for, and billing the second half of one answer would charge for a wait the server chose. |
 | `get_amazon_product` | 3 | One listing by ASIN or URL: price, rating, the full star histogram, features, specs, Amazon's review digest and aspect breakdown, and the reviews. |
+| `scan_marketplace_category` | 3 per product collected (30 by default) | The same category read on ten more sites — AliExpress, Cdiscount, Flipkart, Mercado Libre, Lazada, Otto, Rakuten, Trendyol, Jumia and Temu. `marketplace` picks the site; `market` picks the storefront for the sites that have several, and the argument names the real set per site so a model cannot send Otto a Lazada region. Same rollup, same confirmation before spending. |
+| `marketplace_scan_status` | free | Picks a running marketplace collection back up by `scanId` and the same `marketplace`. Free, for the same reason `amazon_scan_status` is. |
+| `get_marketplace_product` | 3 | One product from any of the eleven sites, by id or URL: price, rating, the full star histogram, specs and the reviews. |
 | `show_amazon_category_insights` | free | Draws the read **your model** wrote — purchase drivers, barriers, what each brand does well, the gaps, the positioning angles — beside the listings and their reviews, so a person can click a product and check any claim against the text it came from. The conclusions are attributed to your model, never presented as a nooticr rating of anyone's product. Makes no requests. |
 
 ### Make something

package/dist/shared/amazon.js

@@ -104,8 +104,11 @@ export function allReviews(products) {
  * rule in CLAUDE.md.
  */
 export function categoryGuidance(opts) {
+    const site = opts.site ?? "Amazon";
+    const statusTool = opts.statusTool ?? "amazon_scan_status";
+    const insightsTool = opts.insightsTool === undefined ? "show_amazon_category_insights" : opts.insightsTool;
     const lines = [];
-    lines.push(`Here are ${opts.products} Amazon listing${opts.products === 1 ? "" : "s"} for ${opts.label}` +
+    lines.push(`Here are ${opts.products} ${site} listing${opts.products === 1 ? "" : "s"} for ${opts.label}` +
         `, carrying ${opts.reviews} review${opts.reviews === 1 ? "" : "s"}` +
         (opts.ratingsRepresented
             ? ` and the star histograms behind ${opts.ratingsRepresented.toLocaleString("en-US")} ratings.`
@@ -114,7 +117,7 @@ export function categoryGuidance(opts) {
         lines.push(`Brands in the set: ${opts.brands.join(", ")}.`);
     if (!opts.complete) {
         lines.push(`Collection is still running — ${opts.pending} listing${opts.pending === 1 ? "" : "s"} to go. ` +
-            `Everything below is real and usable now; call amazon_scan_status with scanId "${opts.scanId}" ` +
+            `Everything below is real and usable now; call ${statusTool} with scanId "${opts.scanId}" ` +
             `for the rest before you write a final read.`);
     }
     lines.push("");
@@ -127,8 +130,10 @@ export function categoryGuidance(opts) {
     }
     lines.push("");
     lines.push("Judge only from what the reviews say. Where the evidence is thin, say so rather than", "producing a confident line the text does not support — a category read that overstates its", "basis is worse than a short one. Prices, ratings and mention counts are in the payload;", "do not re-derive them by hand.");
-    lines.push("");
-    lines.push("To show the result in the conversation — products, their reviews, and your read side by", "side — call show_amazon_category_insights with what you concluded. It costs nothing and", "makes no further requests.");
+    if (insightsTool) {
+        lines.push("");
+        lines.push("To show the result in the conversation — products, their reviews, and your read side by", `side — call ${insightsTool} with what you concluded. It costs nothing and`, "makes no further requests.");
+    }
     return lines.join("\n");
 }
 /**

package/dist/shared/loading-plans.js

@@ -384,6 +384,48 @@ export const LOADING_PLANS = {
             },
         ],
     },
+    // The same three jobs on the other ten sites. Priced identically because
+    // they are the same work — a real browser render behind the site's bot
+    // defences — and the note does not name Amazon, because ten of the eleven
+    // are not it.
+    scan_marketplace_category: {
+        label: "Collecting the category",
+        kind: "list",
+        n: 6,
+        steps: [],
+        perUnit: [
+            {
+                via: "scan_marketplace_category",
+                label: "Collecting a product",
+                detail: "price, stars and its reviews",
+                credits: 3,
+                arg: "limit",
+                defaultCount: 10,
+            },
+        ],
+        note: "Each site is collected politely, so this is minutes rather than seconds. Partial results come back either way.",
+    },
+    // Free: the poll of a collection already paid for.
+    marketplace_scan_status: {
+        label: "Checking the collection",
+        kind: "list",
+        n: 6,
+        steps: [],
+        free: true,
+    },
+    get_marketplace_product: {
+        label: "Reading the product",
+        kind: "text",
+        n: 1,
+        steps: [
+            {
+                via: "get_marketplace_product",
+                label: "Fetching the product",
+                detail: "price, stars and its reviews",
+                credits: 3,
+            },
+        ],
+    },
     // ─── Own-account reads: nooticr's own stored rows ───
     get_scheduled_posts: { label: "Reading your pipeline", kind: "list", n: 5, steps: [], free: true },
     get_post_performance: { label: "Reading your numbers", kind: "list", n: 5, steps: [], free: true },

package/dist/shared/marketplace.js

@@ -0,0 +1,374 @@
+import { z } from "zod";
+import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+import { viewMeta } from "./view-meta.js";
+import { withEvidence } from "./evidence-digest.js";
+import { confirmSpend, declinedResult } from "./spend.js";
+import { allReviews, categoryGuidance, listingCount, normaliseProducts, scanCost } from "./amazon.js";
+/**
+ * The eleven sites, mirroring `MARKETPLACES` in nooticr-server.
+ *
+ * Kept in the same order and the same words deliberately: a model reads this
+ * text to decide what to send, and the server refuses on the same terms. Two
+ * registries that drift are how a tool starts describing an argument the
+ * collector no longer accepts.
+ */
+export const MARKETS = [
+    {
+        slug: "amazon",
+        label: "Amazon",
+        idLabel: "an ASIN or a full Amazon product URL",
+        region: {
+            field: "domain",
+            hint: "a country code or host — com (US), co.uk, de, fr, it, es, ca, co.jp, in, com.br, " +
+                "com.mx, com.au, nl, se, pl, com.be, com.tr, ae, sa, eg, sg, cn. Default www.amazon.com",
+        },
+    },
+    {
+        slug: "aliexpress",
+        label: "AliExpress",
+        idLabel: "the numeric id from /item/<id>.html, or a full AliExpress product URL",
+    },
+    {
+        slug: "cdiscount",
+        label: "Cdiscount",
+        idLabel: "the SKU from a product URL's /f-<category>-<sku>.html, or the full URL",
+    },
+    {
+        slug: "flipkart",
+        label: "Flipkart",
+        idLabel: "the 16-character PID from a product URL's pid= parameter, or the full URL",
+    },
+    {
+        slug: "mercadolibre",
+        label: "Mercado Libre",
+        idLabel: "a site id such as MLA904253674, or a full Mercado Libre product URL",
+        region: {
+            field: "market",
+            hint: "one of eighteen markets, named however it comes to hand — MLB, br, Brazil or " +
+                "mercadolivre.com.br. Inferred from the ids when omitted, and a job runs against one " +
+                "market: an id from another is refused rather than mis-filed",
+        },
+    },
+    {
+        slug: "lazada",
+        label: "Lazada",
+        idLabel: "the number after -i in a product URL (13711387806 in /products/<slug>-i13711387806.html), " +
+            "or the full URL",
+        region: {
+            field: "market",
+            hint: "sg, my, th, vn, ph or id. An item id is scoped to one of them — the same id on another " +
+                "Lazada host is a different product or nothing at all",
+        },
+    },
+    {
+        slug: "otto",
+        label: "Otto",
+        idLabel: "the tail of the product path — C1720803139 on otto.de, or the SKU AKLBB2029107352 on " +
+            "ottoversand.at",
+        region: {
+            field: "market",
+            hint: "de or at. The two are not interchangeable: an id from one does not address a product " +
+                "on the other",
+        },
+    },
+    {
+        slug: "rakuten",
+        label: "Rakuten",
+        idLabel: "on Ichiba `<shopId>_<itemId>` (411453_10000003) or `<shop>/<manageNumber>`; on Taiwan " +
+            "`<shop>/<productCode>`. A full product URL works too",
+        region: {
+            field: "market",
+            hint: "jp (Ichiba) or tw. Taiwan publishes no review text, so a category study there reads on " +
+                "price and rating alone",
+        },
+    },
+    {
+        slug: "trendyol",
+        label: "Trendyol",
+        idLabel: "the number after -p- in a product URL (819066262 in /brand/name-p-819066262), or the full URL",
+        region: {
+            field: "market",
+            hint: "one of 47 storefronts — tr, de, ae, sa, at, be, fr, it, nl, pl, ro and the rest. An id " +
+                "is scoped to one: the same number 404s on another country's",
+        },
+    },
+    {
+        slug: "jumia",
+        label: "Jumia",
+        idLabel: "a SKU such as OR537EA86PWGTNAFAMZ. A product URL does NOT contain it — the number at the " +
+            "end of a product path is a different handle — so reach a product through `query` instead",
+        region: { field: "market", hint: "ng, eg, ke, ma, ci, gh, sn, tn, ug or dz" },
+    },
+    {
+        slug: "temu",
+        label: "Temu",
+        idLabel: "the goods id after -g- in a product URL, or the full URL",
+    },
+];
+const BY_SLUG = new Map(MARKETS.map((m) => [m.slug, m]));
+export function marketOf(slug) {
+    return typeof slug === "string" ? BY_SLUG.get(slug.toLowerCase().trim()) : undefined;
+}
+/** "amazon | aliexpress | ..." — the set, for a description. */
+const SLUGS = MARKETS.map((m) => m.slug).join(", ");
+/**
+ * The storefront argument, described site by site.
+ *
+ * One string rather than eleven schemas, because a tool takes one `marketplace`
+ * per call and the host shows the whole description whichever it picks. Sites
+ * with a single storefront are named as taking none, so a model does not
+ * invent one for Temu.
+ */
+const MARKET_HINT = MARKETS.filter((m) => m.region)
+    .map((m) => `${m.label}: ${m.region.hint}`)
+    .join(" · ") +
+    ` · ${MARKETS.filter((m) => !m.region).map((m) => m.label).join(", ")} have one storefront each ` +
+    "and take no market argument.";
+/** The product ids each site addresses by, for `items`. */
+const ID_HINT = MARKETS.map((m) => `${m.label}: ${m.idLabel}`).join(" · ");
+function structured(res) {
+    return (res.structured ?? {});
+}
+function toolError(what, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { isError: true, content: [{ type: "text", text: `${what}: ${message}` }] };
+}
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+/**
+ * The scan, in the shape the view and the digest read.
+ *
+ * The Amazon twin of this hardcodes its own slug and `domain`; a scan here
+ * carries whichever site it ran against and the storefront under the one name
+ * `market`, because each collector calls it something different and a caller
+ * should not have to know which.
+ */
+function marketplaceResult(payload, m, focus) {
+    const products = normaliseProducts(payload.products);
+    const rollup = (payload.rollup ?? {});
+    const reviews = allReviews(products);
+    const progress = (payload.progress ?? {});
+    const total = num(progress.total) ?? products.length;
+    const done = num(progress.done) ?? products.length;
+    const label = String(payload.query ?? "") ||
+        (products.length === 1 ? String(products[0]?.title ?? "this listing") : "this set of listings");
+    const guidance = categoryGuidance({
+        label,
+        products: products.length,
+        reviews: reviews.length,
+        ratingsRepresented: num(rollup.ratingsRepresented) ?? 0,
+        brands: Array.isArray(rollup.brands) ? rollup.brands : [],
+        complete: payload.complete !== false,
+        scanId: String(payload.scanId ?? ""),
+        pending: Math.max(0, total - done),
+        focus,
+        site: m.label,
+        statusTool: "marketplace_scan_status",
+        // There is no free insights view for these sites yet, and pointing a model
+        // at show_amazon_category_insights would have it draw a Lazada scan as an
+        // Amazon one. Better to say nothing than to name the wrong tool.
+        insightsTool: null,
+    });
+    const structuredPayload = {
+        guidance,
+        mode: "evidence",
+        marketplace: m.slug,
+        scanId: payload.scanId ?? null,
+        status: payload.status ?? null,
+        complete: payload.complete !== false,
+        query: payload.query ?? null,
+        market: payload.market ?? payload.domain ?? null,
+        progress,
+        rollup,
+        products,
+        reviews,
+        errors: payload.errors ?? [],
+        mcpCredits: payload.mcpCredits ?? null,
+    };
+    return {
+        content: [{ type: "text", text: withEvidence(guidance, structuredPayload) }],
+        structuredContent: structuredPayload,
+    };
+}
+/** The `marketplace` argument, shared by all three tools. */
+const marketplaceArg = z
+    .enum(MARKETS.map((m) => m.slug))
+    .describe(`Which site to read. One of: ${SLUGS}.`);
+export function registerMarketplaceTools(server, makeClient) {
+    server.registerTool("scan_marketplace_category", {
+        title: "Scan Marketplace Category",
+        _meta: viewMeta("scan_marketplace_category"),
+        description: "Collect a category from any of eleven marketplaces and read it: products with prices, " +
+            "star histograms, the review text itself, and the arithmetic over them (price spread, " +
+            "rating spread, which aspects recur across how many brands, and the share of each " +
+            "product's ratings sitting at 1-2 stars). `marketplace` picks the site — one of " +
+            `${SLUGS}. ` +
+            "Pass `query` to search the category, `items` to pin named competitors by id or URL, or " +
+            "both. You write the read: purchase drivers, barriers, what the incumbents do well, the " +
+            "gaps, and how a new entrant could position. " +
+            "Costs 3 nooticr credits per product collected — a product with reviews is a real browser " +
+            "render behind the site's bot defences. " +
+            "Collection runs in the background: this returns everything ready within `waitSeconds` " +
+            "plus a scanId to continue with marketplace_scan_status, which is free and worth " +
+            "repeating until the scan is done. " +
+            "For Amazon specifically, scan_amazon_category returns the same shape plus Amazon's own " +
+            "review-aspect counts.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        outputSchema: OUTPUT_SCHEMAS.scan_marketplace_category,
+        inputSchema: z
+            .object({
+            marketplace: marketplaceArg,
+            query: z.string().optional().describe("Category or keyword to search, e.g. 'cast iron skillet'."),
+            items: z
+                .array(z.string())
+                .optional()
+                .describe(`Named competitors, by product id or URL. ${ID_HINT}`),
+            limit: z.number().int().optional().describe("Products to collect (default 10, max 50)."),
+            reviews: z
+                .boolean()
+                .optional()
+                .describe("Collect review text too (default true). False is faster and much cheaper to run, " +
+                "but leaves only the aggregates."),
+            market: z
+                .string()
+                .optional()
+                .describe(`The storefront to read, for the sites that have more than one. ${MARKET_HINT}`),
+            domain: z
+                .string()
+                .optional()
+                .describe("Amazon only: the marketplace host, e.g. www.amazon.co.uk. Other sites use `market`."),
+            waitSeconds: z
+                .number()
+                .int()
+                .optional()
+                .describe("How long to wait before returning partial results (default 45, max 55). " +
+                "Capped under the 60s at which hosts abandon a tool call — asking for longer " +
+                "returns nothing and loses the scanId, not a bigger answer. " +
+                "Poll marketplace_scan_status for the rest instead; it is free and repeatable."),
+            focus: z
+                .string()
+                .optional()
+                .describe("An extra question to answer from the reviews, e.g. 'what do buyers say about sizing?'"),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const m = marketOf(args.marketplace);
+        if (!m)
+            return toolError("scan_marketplace_category failed", new Error(`unknown marketplace — one of ${SLUGS}`));
+        try {
+            // `focus` steers the guidance, not the collection — sending it upstream
+            // would be an argument the backend silently drops.
+            const { focus, ...upstream } = args;
+            // Priced and confirmed before the scan starts, on the same terms as
+            // the Amazon one: a started scan has already spent the expensive half.
+            const credits = scanCost(args);
+            const decision = await confirmSpend(server.server, {
+                credits,
+                summary: `Collect ${listingCount(args)} ${m.label} product(s)` +
+                    (typeof args.query === "string" && args.query ? ` for "${args.query}"` : "") +
+                    `, with their reviews.`,
+                cheaper: 'Lower "limit", or name the competitors you care about in "items".',
+            });
+            if (!decision.proceed) {
+                return declinedResult(credits, `Collecting ${listingCount(args)} ${m.label} product(s)`, 'Lower "limit", or name the competitors you care about in "items".');
+            }
+            const res = await client.callTool("scan_marketplace_category", upstream);
+            return marketplaceResult(structured(res), m, typeof focus === "string" ? focus : undefined);
+        }
+        catch (err) {
+            return toolError("scan_marketplace_category failed", err);
+        }
+    });
+    server.registerTool("marketplace_scan_status", {
+        title: "Marketplace Scan Status",
+        _meta: viewMeta("marketplace_scan_status"),
+        description: "Pick up a scan_marketplace_category collection that was still running, by scanId and the " +
+            "same marketplace — the products and reviews collected since, with the same rollup and " +
+            "the same instructions for reading them. Free: it is the poll scan_marketplace_category " +
+            "asked for, and charging for the second half of one answer would bill a wait this server " +
+            "chose. Call it when a scan came back incomplete, then write your read from the full set.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        outputSchema: OUTPUT_SCHEMAS.marketplace_scan_status,
+        inputSchema: z
+            .object({
+            marketplace: marketplaceArg,
+            scanId: z.string().describe("The scanId scan_marketplace_category returned."),
+            waitSeconds: z
+                .number()
+                .int()
+                .optional()
+                .describe("How long to wait for more products before answering (default 30, max 55). " +
+                "Call it again as often as you need rather than asking for one long wait."),
+            focus: z.string().optional().describe("Same optional steer as scan_marketplace_category."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const m = marketOf(args.marketplace);
+        if (!m)
+            return toolError("marketplace_scan_status failed", new Error(`unknown marketplace — one of ${SLUGS}`));
+        try {
+            const { focus, ...upstream } = args;
+            const res = await client.callTool("marketplace_scan_status", upstream);
+            return marketplaceResult(structured(res), m, typeof focus === "string" ? focus : undefined);
+        }
+        catch (err) {
+            return toolError("marketplace_scan_status failed", err);
+        }
+    });
+    server.registerTool("get_marketplace_product", {
+        title: "Get Marketplace Product",
+        _meta: viewMeta("get_marketplace_product"),
+        description: "Fetch one product from any of eleven marketplaces by id or URL: price, rating, the full " +
+            "star histogram, specs, and the review text. `marketplace` picks the site — one of " +
+            `${SLUGS}. ` +
+            "Costs 3 nooticr credits. " +
+            "Use for a single product; for a category or a competitive set, scan_marketplace_category " +
+            "collects many in one job and rolls them up.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        outputSchema: OUTPUT_SCHEMAS.get_marketplace_product,
+        inputSchema: z
+            .object({
+            marketplace: marketplaceArg,
+            id: z.string().optional().describe(`The product id. ${ID_HINT}`),
+            url: z.string().optional().describe("The full product URL, if you have that instead."),
+            reviews: z.boolean().optional().describe("Collect review text too (default true)."),
+            market: z
+                .string()
+                .optional()
+                .describe(`The storefront the product is on, for sites that have more than one. ${MARKET_HINT}`),
+            domain: z
+                .string()
+                .optional()
+                .describe("Amazon only: the marketplace host. Other sites use `market`."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const m = marketOf(args.marketplace);
+        if (!m)
+            return toolError("get_marketplace_product failed", new Error(`unknown marketplace — one of ${SLUGS}`));
+        try {
+            const res = await client.callTool("get_marketplace_product", args);
+            return marketplaceResult(structured(res), m);
+        }
+        catch (err) {
+            return toolError("get_marketplace_product failed", err);
+        }
+    });
+}

package/dist/shared/output-schemas.js

@@ -293,6 +293,16 @@ const amazonScanShape = {
     errors: anyList(),
     mcpCredits,
 };
+/**
+ * A marketplace scan: the Amazon shape with the storefront reported under one
+ * name. `domain` is Amazon's word for it and the others each have their own,
+ * so the generic tools answer with `market` whichever site ran.
+ */
+const marketplaceScanShape = {
+    ...amazonScanShape,
+    market: scalar().describe("The storefront this ran against, however the site names it."),
+};
+const marketplaceScan = open(marketplaceScanShape);
 const amazonScan = open(amazonScanShape);
 export const OUTPUT_SCHEMAS = {
     analyze_post: open({ ...analyzed, ...evidence }),
@@ -1378,6 +1388,17 @@ export const OUTPUT_SCHEMAS = {
     // names for one payload and three places for the view to drift.
     scan_amazon_category: amazonScan,
     amazon_scan_status: amazonScan,
+    // The same shape on ten more sites. `marketplace` says which one and
+    // `market` which of its storefronts — the Amazon pair reports the storefront
+    // as `domain`, because that is what Amazon calls it, and every other
+    // collector names it differently again. One key here, so a caller reading
+    // the result does not have to know which site it asked.
+    scan_marketplace_category: marketplaceScan,
+    marketplace_scan_status: marketplaceScan,
+    get_marketplace_product: open({
+        ...marketplaceScanShape,
+        product: amazonProduct.nullish().describe("The single product, also present as products[0]."),
+    }),
     get_amazon_product: open({
         ...amazonScanShape,
         product: amazonProduct.nullish().describe("The single listing, also present as products[0]."),

package/dist/shared/tools-def.js

@@ -432,6 +432,24 @@ export const TOOL_DEFINITIONS = [
         description: "Fetch one Amazon listing by ASIN or URL: price, rating, the full star histogram, features, specs, Amazon's review digest and aspect breakdown, and the review text. Use for a single product; for a category or a competitive set, scan_amazon_category collects many in one job and rolls them up. Consumes 3 nooticr credits.",
         inputSchema: z.object({ asin: z.string().optional().describe("ASIN, or a full Amazon product URL."), url: z.string().optional().describe("Full Amazon product URL, if you have that instead."), reviews: z.boolean().optional().describe("Collect review text too (default true)."), domain: z.string().optional().describe("Marketplace host (default www.amazon.com).") }).strict(),
     },
+    {
+        name: "scan_marketplace_category",
+        title: "Scan Marketplace Category",
+        description: "Collect a category from any of eleven marketplaces and read it: products with prices, star histograms, the review text itself, and the arithmetic over them (price spread, rating spread, which aspects recur across how many brands, and the share of each product's ratings sitting at 1-2 stars). marketplace picks the site — one of amazon, aliexpress, cdiscount, flipkart, mercadolibre, lazada, otto, rakuten, trendyol, jumia, temu. Pass query to search the category, items to pin named competitors by id or URL, or both. You write the read: purchase drivers, barriers, what the incumbents do well, the gaps, and how a new entrant could position. Collection runs in the background, so this returns everything ready within waitSeconds plus a scanId to continue with marketplace_scan_status — that is free, and repeating it is how a scan gets more time. For Amazon specifically, scan_amazon_category returns the same shape plus Amazon's own review-aspect counts. Consumes 3 nooticr credits per product collected — a product with reviews is a real browser render behind the site's bot defences.",
+        inputSchema: z.object({ marketplace: z.string().describe("Which site to read. One of: amazon, aliexpress, cdiscount, flipkart, mercadolibre, lazada, otto, rakuten, trendyol, jumia, temu."), query: z.string().optional().describe("Category or keyword to search, e.g. 'cast iron skillet'."), items: z.array(z.string()).optional().describe("Named competitors, by product id or URL."), limit: z.number().int().optional().describe("Products to collect (default 10, max 50)."), reviews: z.boolean().optional().describe("Collect review text too (default true)."), market: z.string().optional().describe("The storefront to read, for the sites that have more than one. Amazon: a country code or host — com (US), co.uk, de, fr and the rest, default www.amazon.com · Mercado Libre: one of eighteen markets, named however it comes to hand — MLB, br, Brazil · Lazada: sg, my, th, vn, ph or id · Otto: de or at · Rakuten: jp (Ichiba) or tw · Trendyol: one of 47 storefronts — tr, de, ae, sa and the rest · Jumia: ng, eg, ke, ma, ci, gh, sn, tn, ug or dz · AliExpress, Cdiscount, Flipkart and Temu have one storefront each and take no market argument. An id is scoped to one storefront: the same id on another is a different product or nothing at all."), domain: z.string().optional().describe("Amazon only: the marketplace host. Other sites use market."), waitSeconds: z.number().int().optional().describe("How long to wait before returning partial results (default 45, max 55). Poll marketplace_scan_status for the rest instead; it is free and repeatable."), focus: z.string().optional().describe("An extra question to answer from the reviews.") }).strict(),
+    },
+    {
+        name: "marketplace_scan_status",
+        title: "Marketplace Scan Status",
+        description: "Pick up a scan_marketplace_category collection that was still running, by scanId and the same marketplace — the products and reviews collected since, with the same rollup and the same instructions for reading them. Free: it is the poll scan_marketplace_category asked for, and charging for the second half of one answer would bill a wait this server chose. Call it when a scan came back incomplete, then write your read from the full set.",
+        inputSchema: z.object({ marketplace: z.string().describe("The same site the scan ran against."), scanId: z.string().describe("The scanId scan_marketplace_category returned."), waitSeconds: z.number().int().optional().describe("How long to wait for more products before answering (default 30, max 55)."), focus: z.string().optional().describe("Same optional steer as scan_marketplace_category.") }).strict(),
+    },
+    {
+        name: "get_marketplace_product",
+        title: "Get Marketplace Product",
+        description: "Fetch one product from any of eleven marketplaces by id or URL: price, rating, the full star histogram, specs, and the review text. marketplace picks the site — one of amazon, aliexpress, cdiscount, flipkart, mercadolibre, lazada, otto, rakuten, trendyol, jumia, temu. Use for a single product; for a category or a competitive set, scan_marketplace_category collects many in one job and rolls them up. Consumes 3 nooticr credits.",
+        inputSchema: z.object({ marketplace: z.string().describe("Which site the product is on. One of: amazon, aliexpress, cdiscount, flipkart, mercadolibre, lazada, otto, rakuten, trendyol, jumia, temu."), id: z.string().optional().describe("The product id, in whatever form the site addresses products by."), url: z.string().optional().describe("The full product URL, if you have that instead."), reviews: z.boolean().optional().describe("Collect review text too (default true)."), market: z.string().optional().describe("The storefront the product is on, for sites that have more than one. Amazon: a country code or host — com (US), co.uk, de, fr and the rest, default www.amazon.com · Mercado Libre: one of eighteen markets, named however it comes to hand — MLB, br, Brazil · Lazada: sg, my, th, vn, ph or id · Otto: de or at · Rakuten: jp (Ichiba) or tw · Trendyol: one of 47 storefronts — tr, de, ae, sa and the rest · Jumia: ng, eg, ke, ma, ci, gh, sn, tn, ug or dz · AliExpress, Cdiscount, Flipkart and Temu have one storefront each and take no market argument. An id is scoped to one storefront: the same id on another is a different product or nothing at all."), domain: z.string().optional().describe("Amazon only: the marketplace host. Other sites use market.") }).strict(),
+    },
     {
         name: "show_amazon_category_insights",
         title: "Show Amazon Category Insights",

package/dist/shared/tools.js

@@ -26,8 +26,9 @@ import { loadingPlansJson } from "./loading-plans.js";
 import { registerHandoff } from "./handoff.js";
 import { registerCollabTools } from "./collab.js";
 import { registerAmazonTools } from "./amazon.js";
+import { registerMarketplaceTools } from "./marketplace.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.36";
+export const MCP_SERVER_VERSION = "1.26.37";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -645,6 +646,12 @@ export function createMcpServer(rawMakeClient, opts) {
         "amazon_scan_status",
         "get_amazon_product",
         "show_amazon_category_insights",
+        // The marketplace-agnostic trio. Every name here gets a ui://nooticr/<tool>
+        // resource, which is what gives a tool its card — a tool missing from this
+        // list is one the host is told to render and then 404s on.
+        "scan_marketplace_category",
+        "marketplace_scan_status",
+        "get_marketplace_product",
     ];
     // Human-readable resource name per tool (used in resources/list + tools/list).
     function resourceName(tool) {
@@ -2387,5 +2394,10 @@ export function createMcpServer(rawMakeClient, opts) {
     // that picks it back up, a single listing, and the free view for the read
     // the model writes out of them.
     registerAmazonTools(server, makeClient);
+    // The same three jobs on the other ten sites (marketplace.ts). Registered
+    // separately because Amazon's collector returns its own review-aspect counts
+    // and the generic one cannot, so the two descriptions are not the same
+    // promise — not because the question differs.
+    registerMarketplaceTools(server, makeClient);
     return server;
 }

package/dist/shared/ui-template.js

@@ -51,7 +51,13 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
     list_social_connections:"Connected Accounts",
     connect_social_account:"Connect an Account",
     create_product:"Add a Product",
-    update_product:"Update a Product"
+    update_product:"Update a Product",
+    scan_amazon_category:"Scan Amazon Category",
+    amazon_scan_status:"Amazon Scan Status",
+    get_amazon_product:"Get Amazon Product",
+    scan_marketplace_category:"Scan Marketplace Category",
+    marketplace_scan_status:"Marketplace Scan Status",
+    get_marketplace_product:"Get Marketplace Product"
   };
   var TOOL_DESCS={
     analyze_post:"Frames from the post plus its transcript, for you to read yourself.",
@@ -74,7 +80,13 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
     list_social_connections:"What you have connected, and what each connection is allowed to do.",
     connect_social_account:"A link you open to connect one account. Nothing connects until you approve it.",
     create_product:"Create a product in your own workspace — the row every other own-account tool needs.",
-    update_product:"Patch a product's fields. An omitted field keeps the value it had."
+    update_product:"Patch a product's fields. An omitted field keeps the value it had.",
+    scan_amazon_category:"A category on Amazon — prices, ratings and what reviewers keep raising.",
+    amazon_scan_status:"The listings an Amazon scan has collected so far.",
+    get_amazon_product:"One Amazon listing: price, rating, star histogram and reviews.",
+    scan_marketplace_category:"A category on any of eleven marketplaces — prices, ratings and review themes.",
+    marketplace_scan_status:"The products a marketplace scan has collected so far.",
+    get_marketplace_product:"One product from any marketplace: price, rating, histogram and reviews."
   };
 
   // ─── The mark ───
@@ -4037,6 +4049,148 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
     renderAmazon();
   }
 
+  /* ------------------------------------------------------------------ */
+  /* Marketplaces                                                        */
+  /* ------------------------------------------------------------------ */
+
+  /* Eleven sites reach these tools through one contract, so one view draws
+     them all; the slug only decides what the header is called. Before this
+     every marketplace result fell through to the JSON dump at the bottom of
+     renderView — the tools were callable from Claude and ChatGPT and had no
+     interactive view at all. */
+  var MARKET_LABELS={amazon:"Amazon",aliexpress:"AliExpress",cdiscount:"Cdiscount",
+    flipkart:"Flipkart",mercadolibre:"Mercado Libre",lazada:"Lazada",otto:"Otto",
+    rakuten:"Rakuten",trendyol:"Trendyol",jumia:"Jumia",temu:"Temu"};
+  function mLabel(slug){return MARKET_LABELS[String(slug||"").toLowerCase()]||(slug?String(slug):"Marketplace");}
+
+  /* The raw scraper record is snake_case and the rollup's copy is camelCase.
+     Both reach this view, so both spellings are read rather than picking one
+     and quietly dropping half the fields. */
+  function mGet(p,a,b){var v=p[a];if(v===undefined||v===null)v=p[b];return v;}
+
+  /* Display price. The "price" field is already formatted by the collector
+     ("EUR 19.99",
+     "19,99 TL"), so it wins; the number is only formatted when there is no
+     string. A product whose price was not scraped says so rather than
+     printing a zero, which reads as free. */
+  function mPrice(p){
+    var s=mGet(p,"price","price");
+    if(typeof s==="string"&&s.trim())return s.trim();
+    var v=mGet(p,"price_value","priceValue");
+    if(v===undefined||v===null||!isFinite(Number(v)))return "";
+    var c=mGet(p,"currency","currency")||"";
+    return (c?c+" ":"")+Number(v).toFixed(2);
+  }
+
+  function mStars(r){
+    r=Number(r)||0;
+    if(!r)return "";
+    return '<span style="color:var(--amber,#F59E0B);font-weight:700">'+r.toFixed(1)+"</span>";
+  }
+
+  /* One product tile. The image is the reason this view exists rather than a
+     table: a category reads as a shelf, and the collectors already return
+     "images". */
+  function mTile(p){
+    var imgs=p.images;
+    var img=(Array.isArray(imgs)&&imgs.length?imgs[0]:"")||p.image||p.imageUrl||p.image_url||"";
+    var title=String(p.title||p.name||"").slice(0,120);
+    var price=mPrice(p);
+    var rating=Number(mGet(p,"rating","rating"))||0;
+    var count=Number(mGet(p,"rating_count","ratingCount"))||0;
+    var url=String(p.url||"");
+    var seller=String(mGet(p,"brand","seller")||mGet(p,"seller","brand")||"");
+    var media=img
+      ? '<img src="'+esc(img)+'" alt="" loading="lazy" referrerpolicy="no-referrer" style="width:100%;height:110px;object-fit:contain;background:var(--tag);display:block"/>'
+      : '<div style="width:100%;height:110px;background:var(--tag)"></div>';
+    var body='<div style="padding:8px 9px">'
+      +'<div style="font-size:12px;line-height:1.35;font-weight:600;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;min-height:2.7em">'+esc(title)+"</div>"
+      +(seller?'<div style="font-size:11px;color:var(--muted);margin-top:3px">'+esc(seller)+"</div>":"")
+      +'<div style="display:flex;align-items:baseline;gap:6px;margin-top:6px">'
+      +(price?'<span style="font-size:13.5px;font-weight:700">'+esc(price)+"</span>":'<span style="font-size:12px;color:var(--muted)">no price</span>')
+      +"</div>"
+      +(rating?'<div style="font-size:11.5px;color:var(--muted);margin-top:3px">'+mStars(rating)+(count?" · "+fmtNum(count)+" ratings":"")+"</div>":"")
+      +"</div>";
+    var inner=media+body;
+    return '<div style="border:1px solid var(--border);border-radius:10px;overflow:hidden;background:var(--bg-surface,transparent)">'
+      +(url?'<a href="'+esc(url)+'" target="_blank" rel="noopener noreferrer" style="color:inherit;text-decoration:none;display:block">'+inner+"</a>":inner)
+      +"</div>";
+  }
+
+  /* An aspect is coloured by whichever way its brands actually lean. A chip
+     with no lean stays neutral rather than being guessed at, for the same
+     reason the monitor view refuses a sentiment badge. */
+  function mAspect(a){
+    var pos=Number(a.positiveBrands)||0,neg=Number(a.negativeBrands)||0;
+    var cls=pos>neg?"chip-positive":neg>pos?"chip-negative":"chip-neutral";
+    return '<span class="chip '+cls+'">'+esc(String(a.name||""))+' <b>'+fmtNum(a.mentions||0)+"</b></span>";
+  }
+
+  function mStat(label,value){
+    if(value===""||value===undefined||value===null)return "";
+    return '<div><div style="font-size:10.5px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted)">'+esc(label)+"</div>"
+      +'<div style="font-size:15px;font-weight:700;margin-top:2px">'+value+"</div></div>";
+  }
+
+  function marketCard(d){
+    var r=d.rollup||{};
+    var single=d.product&&!Array.isArray(d.products&&d.products.length>1?d.products:null);
+    /* Prefer the raw records: they carry the images, and the rollup's copy of
+       each product exists for the arithmetic rather than for drawing. */
+    var rows=(Array.isArray(d.products)&&d.products.length?d.products:(r.perProduct||[])).slice(0,24);
+    var running=d.complete===false;
+    var prog=d.progress||{};
+    var done=Number(prog.done)||0,total=Number(prog.total)||0;
+    var pct=total>0?Math.min(100,Math.round(done/total*100)):0;
+
+    var head='<div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap">'
+      +'<span style="font-size:16px;font-weight:700">'+esc(mLabel(d.marketplace))+"</span>"
+      +(d.query?'<span style="font-size:13px;color:var(--muted)">'+esc(String(d.query))+"</span>":"")
+      +(d.market?'<span class="chip chip-neutral">'+esc(String(d.market))+"</span>":"")
+      +(running?'<span class="chip chip-neutral">collecting</span>':"")
+      +"</div>";
+
+    var bar=running&&total>0
+      ? '<div style="margin-top:8px"><div style="height:4px;border-radius:999px;background:var(--tag);overflow:hidden">'
+        +'<div style="height:100%;width:'+pct+'%;background:var(--green,#16A34A)"></div></div>'
+        +'<div style="font-size:11.5px;color:var(--muted);margin-top:4px">'+done+" of "+total
+        +(prog.message?" · "+esc(String(prog.message)):"")+"</div></div>"
+      : "";
+
+    var price=r.price||{},rating=r.rating||{};
+    var money=function(v){return (v===undefined||v===null)?"":Number(v).toFixed(2);};
+    var stats='<div style="display:grid;grid-template-columns:repeat(4,1fr);gap:10px;margin-top:12px">'
+      +mStat("Products",fmtNum(r.products||rows.length||0))
+      +mStat("Median price",money(price.median))
+      +mStat("Rating",rating.mean?Number(rating.mean).toFixed(2):"")
+      +mStat("Ratings behind it",r.ratingsRepresented?fmtNum(r.ratingsRepresented):"")
+      +"</div>";
+
+    /* Both numbers, because they are not the same claim: a scrape reads a few
+       dozen review texts while the stars average tens of thousands, and
+       showing only the first invites reading it as the category's whole
+       voice. */
+    var reviews=r.reviewsCollected
+      ? '<div style="font-size:11.5px;color:var(--muted);margin-top:8px">'
+        +fmtNum(r.reviewsCollected)+" review texts read"
+        +(r.reviewsGatedProducts?" · "+r.reviewsGatedProducts+" products gated":"")+"</div>"
+      : "";
+
+    var aspects=(r.aspects||[]).slice(0,10);
+    var aspectHtml=aspects.length
+      ? '<div style="margin-top:14px"><div class="sec-label">What reviewers raise</div>'
+        +'<div class="chiprow">'+aspects.map(mAspect).join("")+"</div></div>"
+      : "";
+
+    var grid=rows.length
+      ? '<div style="margin-top:14px"><div class="sec-label">'+(single?"Product":"Products")+"</div>"
+        +'<div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:10px">'
+        +rows.map(mTile).join("")+"</div></div>"
+      : '<div style="font-size:12.5px;color:var(--muted);margin-top:12px">Nothing collected yet.</div>';
+
+    return '<div class="card card-wide fade-in"><div class="card-body">'+head+bar+stats+reviews+aspectHtml+grid+"</div></div>";
+  }
+
   function renderView(result){
     var app=document.getElementById("app");if(!app)return;
     var d=extractResult(result);
@@ -4498,6 +4652,12 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
         +'<div style="display:flex;align-items:center;gap:7px;font-size:16px;font-weight:700;margin-bottom:10px">'+mpIcon("share",16)+"<span>Repurposed</span></div>"
         +versionsHtml+"</div></div>";return;}
 
+    // A marketplace scan or a single product. Matched on "marketplace", which
+    // every one of these results carries and nothing else here does — the
+    // check has to come before the "d.platform" one below, because a scan's
+    // raw product records carry a platform of their own.
+    if(d.marketplace&&(d.rollup||d.product||Array.isArray(d.products))){
+      app.innerHTML=marketCard(d);setTimeout(reportSize,50);return;}
     // Single post
     if(d.post||d.platform){app.innerHTML=postCard(d.post||d,true);return;}
     // Fallback. The guidance field is prose written for the model, not data —

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.36",
+  "version": "1.26.37",
   "description": "MCP server for nooticr - fetch, discover and understand TikTok/Instagram/YouTube/X/Reddit/LinkedIn/Weibo posts with AI (media metadata, niche discovery, brand monitoring, hook & viral analysis)",
   "homepage": "https://mcp.nooticr.com",
   "repository": {