@webcrawl/mcp 0.0.0-stage → 1.2.2

package/README.md

@@ -1,3 +1,51 @@
-# Temporary Holding Version
+# @webcrawl/mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Model Context Protocol (MCP) server for **[Webcrawl Anything](https://github.com/brainfish-ai/webcrawl-anything)** and **[webcrawl.app](https://webcrawl.app)**.
+
+Gives Claude Code, Cursor, Codex, Windsurf, and Gemini CLI live access to web search, structured verticals (shopping, flights, hotels, real-estate, local business, CVEs), anti-bot page scraping, PDF/Office OCR, and YouTube transcripts.
+
+## One-Command Agent Setup
+
+Register `@webcrawl/mcp` and install the `webcrawl-anything` Agent Skill (`SKILL.md`) automatically:
+
+```bash
+npx webcrawl setup
+```
+
+## Manual MCP Configuration
+
+Add to `.cursor/mcp.json`, `~/.claude.json`, or your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "webcrawl": {
+      "command": "npx",
+      "args": ["-y", "@webcrawl/mcp@latest"],
+      "env": {
+        "WEBCRAWL_MCP_SCHEMA_PROFILE": "compact",
+        "WEBCRAWL_API_KEY": "wc_live_..."
+      }
+    }
+  }
+}
+```
+
+### Compact Schema Profile
+
+Set `WEBCRAWL_MCP_SCHEMA_PROFILE=compact` (default when installed via `npx webcrawl setup`) to minimize tool schema token usage in context-constrained agents while keeping full server-side validation. Set `WEBCRAWL_MCP_SCHEMA_PROFILE=full` for verbose parameter descriptions.
+
+## Tools Provided
+
+- `web_search` — Search the web or structured verticals (`shopping`, `flights`, `hotels`, `real-estate`, `business`, `security`, `academic`, `tech`, `news`).
+- `web_scrape` — Fetch a URL and return clean Markdown with target evidence.
+- `web_parse` / `web_parse_status` — Parse PDFs (native + OCR), Word/Excel/PowerPoint files, YouTube videos, and audio/video into Markdown.
+- `web_map` — Discover all URLs on a domain (`sitemap.xml`, `robots.txt`, and link graph).
+- `web_crawl` — Crawl up to 25 pages starting from a URL.
+- `web_extract` — Extract structured JSON from a URL using a prompt or JSON Schema.
+- `web_rerank` — Rerank candidate documents by relevance to a query.
+- `search_categories` — List all supported search categories, subcategories, and filters.
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { WebcrawlClient, resolveConfig } from "@webcrawl/client";
+import { createServer, resolveSchemaProfile } from "./server.js";
+const cfg = resolveConfig();
+let client;
+if (cfg.effectiveMode === "local") {
+    try {
+        // Load the shared local engine when running from the monorepo / local install without an API key
+        const localEngineSpec = ["..", "..", "..", "src", "local-engine.js"].join("/");
+        const localMod = (await import(localEngineSpec));
+        client = localMod.createLocalEngineClient();
+        process.stderr.write("webcrawl-mcp: running in zero-key LOCAL engine mode. Set WEBCRAWL_API_KEY (or run `webcrawl login`) to upgrade to webcrawl.app cloud.\n");
+    }
+    catch {
+        process.stderr.write("webcrawl-mcp: no API key configured; falling back to https://webcrawl.app (set WEBCRAWL_API_KEY or run `webcrawl login`).\n");
+        client = new WebcrawlClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, userAgent: "webcrawl-mcp/0.1" });
+    }
+}
+else {
+    client = new WebcrawlClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, userAgent: "webcrawl-mcp/0.1" });
+}
+await createServer(client, { schemaProfile: resolveSchemaProfile() }).connect(new StdioServerTransport());

package/dist/format.d.ts

@@ -0,0 +1,13 @@
+/** Hard cap on text returned by any tool so one call cannot flood the model context. */
+export declare const MAX_OUTPUT_CHARS = 24000;
+export declare function truncate(text: string, max?: number): string;
+type Rec = Record<string, unknown>;
+/** Compact, model-friendly digest of a search response. */
+export declare function formatSearch(res: Rec): string;
+export declare function formatCredits(res: Rec): string;
+export declare function formatScrape(res: Rec): string;
+/** Markdown plus a one-line note on how the file was read (and what was not). */
+export declare function formatParse(res: Rec): string;
+export declare function formatMap(res: Rec): string;
+export declare function formatCrawl(res: Rec): string;
+export {};

package/dist/format.js

@@ -0,0 +1,126 @@
+/** Hard cap on text returned by any tool so one call cannot flood the model context. */
+export const MAX_OUTPUT_CHARS = 24_000;
+export function truncate(text, max = MAX_OUTPUT_CHARS) {
+    if (text.length <= max) {
+        return text;
+    }
+    return `${text.slice(0, max)}\n\n[truncated ${text.length - max} characters]`;
+}
+const isRec = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const str = (v) => (typeof v === "string" ? v : typeof v === "number" ? String(v) : "");
+const first = (o, keys) => {
+    for (const k of keys) {
+        const v = str(o[k]);
+        if (v) {
+            return v;
+        }
+    }
+    return "";
+};
+const VERTICALS = ["products", "offers", "listings", "flights", "hotels", "businesses", "cves"];
+function cveLine(o, i) {
+    const score = str(o.cvssScore);
+    const sev = str(o.severity);
+    const affected = Array.isArray(o.affected) ? o.affected.filter(isRec) : [];
+    const aff = affected
+        .slice(0, 3)
+        .map((a) => [str(a.product), str(a.versions), a.fixed ? `fixed ${str(a.fixed)}` : ""].filter(Boolean).join(" "))
+        .join("; ");
+    const head = [score && `CVSS ${score}`, sev, o.kev === true ? "KEV" : "", str(o.published).slice(0, 10)]
+        .filter(Boolean)
+        .join(" · ");
+    const summary = (str(o.title) || str(o.summary)).slice(0, 220);
+    return `${i + 1}. ${str(o.id)}${head ? ` (${head})` : ""}${summary ? `\n   ${summary}` : ""}${aff ? `\n   affected: ${aff}` : ""}${o.url ? `\n   ${str(o.url)}` : ""}`;
+}
+function line(o, i) {
+    const title = first(o, ["title", "name", "address", "airline", "productName"]) || "(untitled)";
+    const price = first(o, ["priceText", "price", "pricePerNight", "minPrice"]);
+    const src = first(o, ["provider", "portal", "vendor", "domain", "source"]);
+    const url = first(o, ["url", "link"]);
+    const meta = [price, src].filter(Boolean).join(" · ");
+    return `${i + 1}. ${title}${meta ? ` (${meta})` : ""}${url ? `\n   ${url}` : ""}`;
+}
+/** Compact, model-friendly digest of a search response. */
+export function formatSearch(res) {
+    const parts = [];
+    for (const key of VERTICALS) {
+        const arr = res[key];
+        if (Array.isArray(arr) && arr.length) {
+            parts.push(`${key} (${arr.length}):\n${arr.filter(isRec).map(key === "cves" ? cveLine : line).join("\n")}`);
+        }
+    }
+    const results = Array.isArray(res.results) ? res.results : Array.isArray(res.data) ? res.data : [];
+    if (results.length) {
+        parts.push(`results (${results.length}):\n${results
+            .filter(isRec)
+            .map((r, i) => {
+            const desc = first(r, ["description", "snippet"]).slice(0, 240);
+            return `${line(r, i)}${desc ? `\n   ${desc}` : ""}`;
+        })
+            .join("\n")}`);
+    }
+    return parts.length ? parts.join("\n\n") : "No results.";
+}
+export function formatCredits(res) {
+    const c = res.credits;
+    if (!isRec(c)) {
+        return "";
+    }
+    const bits = [
+        typeof c.charged === "number" ? `charged ${c.charged}` : "",
+        typeof c.remaining === "number" ? `${c.remaining} remaining` : "",
+    ].filter(Boolean);
+    return bits.length ? `\n\n[credits: ${bits.join(", ")}]` : "";
+}
+export function formatScrape(res) {
+    const d = isRec(res.data) ? res.data : res;
+    const title = str(d.title) || (isRec(d.metadata) ? str(d.metadata.title) : "");
+    const md = str(d.markdown) || str(d.content);
+    return `${title ? `# ${title}\n\n` : ""}${md || "(no content returned)"}`;
+}
+/** Markdown plus a one-line note on how the file was read (and what was not). */
+export function formatParse(res) {
+    if (typeof res.id === "string" && res.status === "running") {
+        return `Parsing in the background (run ${res.id}). Check it with web_parse_status.`;
+    }
+    const meta = isRec(res.metadata) && isRec(res.metadata.parse) ? res.metadata.parse : {};
+    const notes = [];
+    if (typeof meta.kind === "string") {
+        notes.push(meta.kind);
+    }
+    if (typeof meta.pages === "number") {
+        notes.push(`${meta.pages} pages`);
+    }
+    if (Array.isArray(meta.pagesOcr) && meta.pagesOcr.length) {
+        notes.push(`OCR on pages ${meta.pagesOcr.join(", ")}`);
+    }
+    if (Array.isArray(meta.pagesSkipped) && meta.pagesSkipped.length) {
+        notes.push(`not read: ${meta.pagesSkipped.filter(isRec).map((s) => `p${s.page} (${str(s.reason)})`).join(", ")}`);
+    }
+    if (typeof meta.durationSeconds === "number") {
+        notes.push(`${Math.round(meta.durationSeconds)}s of audio`);
+    }
+    const warnings = Array.isArray(meta.warnings) ? meta.warnings.filter((w) => typeof w === "string") : [];
+    const head = notes.length ? `[${notes.join("; ")}]\n\n` : "";
+    const tail = warnings.length ? `\n\n[warnings: ${warnings.join(" | ")}]` : "";
+    return head + formatScrape(res) + tail;
+}
+export function formatMap(res) {
+    const links = Array.isArray(res.links) ? res.links : Array.isArray(res.urls) ? res.urls : [];
+    const urls = links.map((l) => (isRec(l) ? str(l.url) : str(l))).filter(Boolean);
+    return urls.length ? `${urls.length} URLs:\n${urls.join("\n")}` : "No URLs found.";
+}
+export function formatCrawl(res) {
+    const pages = Array.isArray(res.data) ? res.data : Array.isArray(res.pages) ? res.pages : [];
+    if (!pages.length) {
+        return "No pages crawled.";
+    }
+    const perPage = Math.max(1_000, Math.floor(MAX_OUTPUT_CHARS / pages.length));
+    return pages
+        .filter(isRec)
+        .map((p) => {
+        const url = str(p.url) || (isRec(p.metadata) ? str(p.metadata.sourceURL) || str(p.metadata.url) : "");
+        return `## ${str(p.title) || url || "page"}\n${url}\n\n${truncate(str(p.markdown), perPage)}`;
+    })
+        .join("\n\n---\n\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer, createWebcrawlMcpServer, resolveSchemaProfile, type McpServerOptions, type SchemaProfile, type WebcrawlLikeClient, } from "./server.js";
+export { MAX_OUTPUT_CHARS, truncate } from "./format.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createServer, createWebcrawlMcpServer, resolveSchemaProfile, } from "./server.js";
+export { MAX_OUTPUT_CHARS, truncate } from "./format.js";

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebcrawlClient } from "@webcrawl/client";
+export type SchemaProfile = "compact" | "full";
+export interface McpServerOptions {
+    version?: string;
+    schemaProfile?: SchemaProfile;
+}
+export type WebcrawlLikeClient = Pick<WebcrawlClient, "baseUrl" | "search" | "scrape" | "parse" | "run" | "map" | "crawl" | "extract" | "rerank" | "categories"> & {
+    targets?: () => Promise<Record<string, unknown>>;
+};
+export declare function resolveSchemaProfile(env?: NodeJS.ProcessEnv): SchemaProfile;
+/**
+ * Builds the webcrawl MCP server around an API or local engine client. Shared by
+ * the stdio binary (`npx webcrawl-mcp`) and the hosted Streamable HTTP endpoint (`webcrawl.app/mcp`).
+ */
+export declare function createWebcrawlMcpServer(client: WebcrawlLikeClient, versionOrOpts?: string | McpServerOptions): McpServer;
+/** Back-compat alias used by the stdio binary. */
+export declare const createServer: typeof createWebcrawlMcpServer;

package/dist/server.js

@@ -0,0 +1,195 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { describeError } from "@webcrawl/client";
+import { z } from "zod";
+import { formatCredits, formatCrawl, formatMap, formatParse, formatScrape, formatSearch, truncate } from "./format.js";
+const INSTRUCTIONS = `Webcrawl Anything gives you live web & target inspection access (zero-key local engine or webcrawl.app cloud).
+- web_search: find pages or structured results. Set category for flights, hotels, real-estate, shopping, news, local business, security (CVEs), academic or tech. Results are localised to the user.
+- web_scrape: read one URL as clean markdown with target evidence (websites, SPAs, GitHub, ArXiv, llms.txt).
+- web_parse: read a PDF, Office file, YouTube video, image, or audio/video at a URL as markdown (OCR and transcripts included). For long files set background and poll web_parse_status.
+- web_map: list the URLs on a site before deciding what to scrape.
+- web_crawl: read several pages of one site (max 25).
+- web_extract: pull structured JSON from one URL with a prompt or schema.
+- web_rerank: order your own documents by relevance to a query.
+- search_categories: list valid categories, subcategories, filters, and supported crawl targets.`;
+const ok = (text) => ({ content: [{ type: "text", text: truncate(text) }] });
+export function resolveSchemaProfile(env = process.env) {
+    const raw = (env.WEBCRAWL_MCP_SCHEMA_PROFILE ||
+        env.WEBCRAWL_MCP_INPUT_SCHEMA_PROFILE ||
+        "full")
+        .trim()
+        .toLowerCase();
+    return raw === "compact" ? "compact" : "full";
+}
+/**
+ * Builds the webcrawl MCP server around an API or local engine client. Shared by
+ * the stdio binary (`npx webcrawl-mcp`) and the hosted Streamable HTTP endpoint (`webcrawl.app/mcp`).
+ */
+export function createWebcrawlMcpServer(client, versionOrOpts = "0.1.0") {
+    const opts = typeof versionOrOpts === "string" ? { version: versionOrOpts } : versionOrOpts;
+    const version = opts.version ?? "0.1.0";
+    const compact = (opts.schemaProfile ?? resolveSchemaProfile()) === "compact";
+    const desc = (schema, text) => compact ? schema : schema.describe(text);
+    const server = new McpServer({ name: "webcrawl", version }, { instructions: INSTRUCTIONS });
+    const run = async (fn) => {
+        try {
+            return ok(await fn());
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: "text", text: describeError(e, client.baseUrl) }] };
+        }
+    };
+    server.registerTool("web_search", {
+        title: "Web search",
+        description: compact
+            ? "Search the web or structured verticals (shopping, flights, hotels, real-estate, business, security CVEs, academic, tech)."
+            : "Search the web. Use `category` for structured results (flights, hotels, real-estate, shopping with prices, news, local business, security: CVE records with CVSS, affected and fixed versions). Results are localised to the user unless a place is given.",
+        inputSchema: {
+            query: desc(z.string().min(1), "What to search for"),
+            category: desc(z.string().optional(), "e.g. general, news, shopping, flights, hotels, real-estate, business, security, academic, tech. See search_categories."),
+            subcategory: desc(z.string().optional(), "e.g. buy or rent for real-estate, cve for security"),
+            limit: desc(z.number().int().min(1).max(20).optional(), "Max results, default 5"),
+            country: desc(z.string().optional(), "ISO country code, e.g. AU"),
+            city: z.string().optional(),
+            sites: desc(z.array(z.string()).optional(), "Only these domains, e.g. [\"booking.com\"]"),
+            include_content: desc(z.boolean().optional(), "Also fetch page markdown for each result (slower, more credits)"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ query, category, subcategory, limit, country, city, sites, include_content }) => run(async () => {
+        const res = await client.search({
+            query,
+            category,
+            subcategory,
+            limit,
+            country,
+            city,
+            sites,
+            scrapeContent: include_content,
+        });
+        return formatSearch(res) + formatCredits(res);
+    }));
+    server.registerTool("web_scrape", {
+        title: "Scrape a page",
+        description: compact
+            ? "Fetch one URL as clean markdown."
+            : "Fetch one URL and return its main content as markdown. Handles JavaScript-heavy and bot-protected pages.",
+        inputSchema: {
+            url: z.string().url(),
+            no_cache: desc(z.boolean().optional(), "Skip cached copy"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ url, no_cache }) => run(async () => {
+        const res = await client.scrape({ url, formats: ["markdown"], noCache: no_cache });
+        return formatScrape(res) + formatCredits(res);
+    }));
+    server.registerTool("web_parse", {
+        title: "Read a file",
+        description: compact
+            ? "Read a PDF, Office file, YouTube link, image, or audio/video URL as Markdown."
+            : "Read a PDF, Word/Excel/PowerPoint file, image, or audio/video file at a URL and return Markdown. Scanned PDF pages are OCR'd; audio/video is transcribed with timestamps. Pages it could not read are listed, never guessed.",
+        inputSchema: {
+            url: z.string().url(),
+            ocr: desc(z.enum(["auto", "force", "off"]).optional(), "auto (default) OCRs only scanned pages"),
+            pages: desc(z.array(z.number().int().min(1)).max(2000).optional(), "1-indexed PDF pages to read"),
+            language: desc(z.string().max(8).optional(), "Spoken language hint, e.g. en"),
+            background: desc(z.boolean().optional(), "Run as a background job for long files; returns a run id"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ url, ocr, pages, language, background }) => run(async () => {
+        const res = await client.parse({ url, ocr, pages, language, async: background });
+        return formatParse(res) + formatCredits(res);
+    }));
+    server.registerTool("web_parse_status", {
+        title: "Check a file read",
+        description: "Check a background web_parse run and return its Markdown when it has finished.",
+        inputSchema: { id: z.string().min(1) },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, ({ id }) => run(async () => {
+        const res = await client.run(id);
+        const result = res.result && typeof res.result === "object"
+            ? res.result
+            : null;
+        if (!result) {
+            return `Run ${id} is ${String(res.status ?? "running")}.`;
+        }
+        return formatParse(result) + formatCredits(result);
+    }));
+    server.registerTool("web_map", {
+        title: "Map a site",
+        description: compact
+            ? "List URLs on a website."
+            : "List the URLs on a website (sitemap, robots and links). Use before scraping to pick the right pages.",
+        inputSchema: {
+            url: z.string().url(),
+            search: desc(z.string().optional(), "Only URLs matching this text"),
+            limit: z.number().int().min(1).max(5000).optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ url, search, limit }) => run(async () => {
+        const res = await client.map({ url, search, limit });
+        return formatMap(res) + formatCredits(res);
+    }));
+    server.registerTool("web_crawl", {
+        title: "Crawl a site",
+        description: compact
+            ? "Crawl up to 25 pages starting from a URL."
+            : "Read several pages starting from a URL and return each as markdown. Capped at 25 pages.",
+        inputSchema: {
+            url: z.string().url(),
+            max_pages: desc(z.number().int().min(1).max(25).optional(), "Default 5"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ url, max_pages }) => run(async () => {
+        const res = await client.crawl({ url, maxPages: max_pages });
+        return formatCrawl(res) + formatCredits(res);
+    }));
+    server.registerTool("web_extract", {
+        title: "Extract structured data",
+        description: compact
+            ? "Extract structured JSON from a URL."
+            : "Pull structured JSON from one URL. Describe what you want with `prompt`, or pass a JSON `schema`.",
+        inputSchema: {
+            url: z.string().url(),
+            prompt: z.string().optional(),
+            schema: desc(z.record(z.string(), z.any()).optional(), "JSON Schema for the output"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, ({ url, prompt, schema }) => run(async () => {
+        const res = await client.extract({ url, prompt, schema });
+        return JSON.stringify(res.data ?? res, null, 2) + formatCredits(res);
+    }));
+    server.registerTool("web_rerank", {
+        title: "Rerank documents",
+        description: compact
+            ? "Order documents by relevance to a query."
+            : "Order your own documents by relevance to a query. Returns the best matches first.",
+        inputSchema: {
+            query: z.string().min(1),
+            documents: z.array(z.string()).min(1).max(200),
+            top_k: z.number().int().min(1).optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, ({ query, documents, top_k }) => run(async () => {
+        const res = await client.rerank({ query, documents, topK: top_k });
+        const items = Array.isArray(res.results)
+            ? res.results
+            : Array.isArray(res.data)
+                ? res.data
+                : [];
+        const lines = items.map((r, i) => {
+            const o = (r ?? {});
+            const text = String(o.description ?? o.markdown ?? o.title ?? "").slice(0, 200);
+            const score = typeof o.score === "number" ? ` [${o.score.toFixed(3)}]` : "";
+            return `${i + 1}.${score} ${text}`;
+        });
+        return (lines.length ? lines.join("\n") : JSON.stringify(res, null, 2)) + formatCredits(res);
+    }));
+    server.registerTool("search_categories", {
+        title: "Search categories",
+        description: "List the search categories, subcategories and filters web_search supports.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, () => run(async () => JSON.stringify(await client.categories(), null, 2)));
+    return server;
+}
+/** Back-compat alias used by the stdio binary. */
+export const createServer = createWebcrawlMcpServer;

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@webcrawl/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.2",
+  "description": "MCP server for Webcrawl Anything — zero-key local engine or webcrawl.app cloud (search, scrape, parse PDF/Office/YouTube, map, crawl, extract, rerank)",
+  "type": "module",
+  "license": "MIT",
+  "author": "Brainfish AI <support@webcrawl.app> (https://webcrawl.app)",
+  "homepage": "https://webcrawl.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brainfish-ai/webcrawl-anything.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/brainfish-ai/webcrawl-anything/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "webcrawl",
+    "web-search",
+    "web-scraper",
+    "pdf-parser",
+    "claude-code",
+    "cursor",
+    "codex",
+    "ai-agents"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "webcrawl-mcp": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "node --conditions=development --import tsx --test test/*.test.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@webcrawl/client": "^1.2.2",
+    "zod": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}