desearch-mcp-server 0.0.1 → 0.1.3

package/build/server.js

@@ -0,0 +1,471 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import DesearchImport from "desearch-js";
+import { z } from "zod";
+import { AI_SEARCH_TOOLS, WEB_LINK_TOOLS, toolIdSchema } from "./tool-sources.js";
+export const SERVER_NAME = "Desearch";
+export const SERVER_VERSION = "0.1.3";
+// desearch-js 1.5 publishes a default class. Node16 resolution types that package
+// as a module namespace, so the constructor is applied through a cast.
+const Desearch = DesearchImport;
+/**
+ * Every tool reads live Desearch, web, or X data and returns it. None of them
+ * write caller state. Hints only: clients must not treat them as a safety check.
+ * destructiveHint is false so a client that ignores the readOnlyHint gate does
+ * not treat a search as a destructive update (the MCP default for that hint is true).
+ */
+const READ_ONLY_OPEN_WORLD = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+};
+const optionalPostCount = z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .optional()
+    .describe("Number of posts to retrieve (1-100).");
+const optionalLinksCount = z
+    .number()
+    .int()
+    .min(10)
+    .max(200)
+    .optional()
+    .describe("Results to return. Min 10. Max 200.");
+function pageContentFields() {
+    return {
+        url: z.string().describe("Public URL to read, example: 'https://desearch.ai'"),
+        format: z
+            .enum(["html", "text"])
+            .optional()
+            .describe("Content format to return: 'html' or 'text'."),
+        js: z.boolean().optional().describe("Render JavaScript before reading the page."),
+        wait: z
+            .number()
+            .optional()
+            .describe("Post-load wait in milliseconds when JavaScript rendering is enabled."),
+    };
+}
+const engagementThreshold = z
+    .union([z.number().int().min(0), z.string()])
+    .optional();
+function definedFields(fields) {
+    const out = {};
+    for (const key of Object.keys(fields)) {
+        if (fields[key] !== undefined) {
+            out[key] = fields[key];
+        }
+    }
+    return out;
+}
+/**
+ * Payload note when a link search body has no link list.
+ * Does not name web vs AI search, and does not say the query had "results".
+ * A missing list (the cost-only API bug) and an empty list are the same note:
+ * this response body does not contain links.
+ */
+export const NO_LINKS_MESSAGE = "no links in response";
+/**
+ * Keys that have carried link lists. `/links/web` uses `search_results`.
+ * AI search has used `search`, `results`, and `data`.
+ */
+const LINK_COLLECTION_KEYS = [
+    "search_results",
+    "results",
+    "links",
+    "search",
+    "data",
+    "youtube_search_results",
+    "hacker_news_search_results",
+    "reddit_search_results",
+    "arxiv_search_results",
+    "wikipedia_search_results",
+    "hacker_news_search",
+    "reddit_search",
+    "youtube_search",
+    "tweets",
+    "miner_tweets",
+];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function linkLists(value) {
+    const lists = [];
+    for (const key of LINK_COLLECTION_KEYS) {
+        const entry = value[key];
+        if (Array.isArray(entry)) {
+            lists.push(entry);
+        }
+    }
+    return lists;
+}
+/**
+ * Pass a link payload through when it contains at least one link.
+ * A cost-only body (billing fields, no link list) and an empty link list
+ * both get `message: "no links in response"` plus the original fields,
+ * including billing. The note does not claim the search returned results
+ * and does not name which search tool produced the body.
+ */
+export function presentSearchBody(value) {
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const lists = linkLists(value);
+    if (lists.some((list) => list.length > 0)) {
+        return value;
+    }
+    return {
+        ...value,
+        message: NO_LINKS_MESSAGE,
+    };
+}
+function ok(value) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+    };
+}
+function fail(label, error) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${label}: ${error instanceof Error ? error.message : String(error)}`,
+            },
+        ],
+        isError: true,
+    };
+}
+function registerTool(server, apiKey, name, title, description, inputSchema, handler) {
+    // SDK 1.30's tool generics blow the TypeScript instantiation limit on these
+    // schemas. Runtime registration is the same registerTool call.
+    const register = server.registerTool.bind(server);
+    const guarded = async (args) => {
+        if (!apiKey) {
+            return fail("Desearch", new Error("Desearch API key required. Send it in the Authorization: Bearer <key> header or the x-api-key header."));
+        }
+        return handler(args);
+    };
+    register(name, {
+        title,
+        description,
+        inputSchema,
+        annotations: { ...READ_ONLY_OPEN_WORLD, title },
+    }, guarded);
+}
+/**
+ * One MCP server bound to a single Desearch API key.
+ * Stdio uses the process env key. Remote HTTP builds a new server per request
+ * so each caller spends their own key.
+ * `client` is a test seam. Production callers omit it and the server builds
+ * a desearch-js client from `apiKey`.
+ */
+export function createDesearchMcpServer(apiKey, client) {
+    const desearch = client ?? new Desearch(apiKey);
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    registerTool(server, apiKey, "ai-search", "AI Search", "AI search and analysis on web using Desearch AI", {
+        prompt: z.string().describe("Question, example: 'What is the latest news on AI?'"),
+        tools: z
+            .array(toolIdSchema(AI_SEARCH_TOOLS))
+            .optional()
+            .default(["web", "twitter"])
+            .describe("Source ids sent to POST /desearch/ai/search. Use short ids such as 'web' and 'twitter'. Legacy labels such as 'Web Search' are accepted and rewritten to those ids. Example: ['web', 'twitter']."),
+        date_filter: z
+            .enum([
+            "PAST_24_HOURS",
+            "PAST_2_DAYS",
+            "PAST_WEEK",
+            "PAST_2_WEEKS",
+            "PAST_MONTH",
+            "PAST_2_MONTHS",
+            "PAST_YEAR",
+            "PAST_2_YEARS",
+        ])
+            .optional()
+            .describe("Deprecated relative window; prefer start_date/end_date. Example: 'PAST_WEEK'"),
+        start_date: z
+            .string()
+            .optional()
+            .describe("Start of the date range in UTC (YYYY-MM-DDTHH:MM:SSZ). Use with end_date."),
+        end_date: z
+            .string()
+            .optional()
+            .describe("End of the date range in UTC (YYYY-MM-DDTHH:MM:SSZ). Use with start_date."),
+        result_type: z
+            .enum(["ONLY_LINKS", "LINKS_WITH_FINAL_SUMMARY"])
+            .optional()
+            .describe("ONLY_LINKS returns links only; LINKS_WITH_FINAL_SUMMARY adds an AI summary. Link arrays are kept under whichever key the API uses, along with billing fields. ONLY_LINKS still depends on the API to include those links."),
+        include_domains: z
+            .array(z.string())
+            .optional()
+            .describe("Restrict Web Search results to these domains, example: ['bbc.com', 'reuters.com']"),
+        exclude_domains: z
+            .array(z.string())
+            .optional()
+            .describe("Drop Web Search results from these domains, example: ['pinterest.com']"),
+        model: z
+            .enum(["NOVA", "ORBIT"])
+            .default("NOVA")
+            .describe("Model to use for the search: NOVA (default) or ORBIT."),
+    }, async ({ prompt, tools, date_filter, start_date, end_date, result_type, include_domains, exclude_domains, model }) => {
+        try {
+            const payload = {
+                prompt,
+                tools,
+                date_filter,
+                start_date,
+                end_date,
+                result_type,
+                include_domains,
+                exclude_domains,
+                model,
+                streaming: false,
+            };
+            return ok(presentSearchBody(await desearch.aiSearch(payload)));
+        }
+        catch (error) {
+            return fail("AI Search error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-search", "X Search", "Search X (Twitter) using Desearch AI. Optional filters narrow by user, date, language, verification, media, and engagement. Sort stays Top.", {
+        query: z
+            .string()
+            .describe("Twitter advanced search query, example: 'from:elonmusk since:2023-01-01 min_replies:10'"),
+        count: z
+            .number()
+            .optional()
+            .default(20)
+            .describe("Number of search results to return (default: 20), max is 100"),
+        user: z.string().optional().describe("User to search for, example: 'elonmusk'"),
+        start_date: z
+            .string()
+            .optional()
+            .describe("Start date in UTC (YYYY-MM-DD). Use with end_date."),
+        end_date: z
+            .string()
+            .optional()
+            .describe("End date in UTC (YYYY-MM-DD). Use with start_date."),
+        lang: z.string().optional().describe("Language code, example: 'en', 'es', 'fr'"),
+        verified: z.boolean().optional().describe("Filter for verified users."),
+        blue_verified: z.boolean().optional().describe("Filter for blue-checkmark verified users."),
+        is_quote: z.boolean().optional().describe("Include only posts that are quotes."),
+        is_video: z.boolean().optional().describe("Include only posts with video."),
+        is_image: z.boolean().optional().describe("Include only posts with images."),
+        min_retweets: engagementThreshold.describe("Minimum number of retweets."),
+        min_replies: engagementThreshold.describe("Minimum number of replies."),
+        min_likes: engagementThreshold.describe("Minimum number of likes."),
+    }, async ({ query, count, user, start_date, end_date, lang, verified, blue_verified, is_quote, is_video, is_image, min_retweets, min_replies, min_likes, }) => {
+        try {
+            return ok(await desearch.xSearch({
+                query,
+                sort: "Top",
+                count,
+                ...definedFields({
+                    user,
+                    start_date,
+                    end_date,
+                    lang,
+                    verified,
+                    blue_verified,
+                    is_quote,
+                    is_video,
+                    is_image,
+                    min_retweets,
+                    min_replies,
+                    min_likes,
+                }),
+            }));
+        }
+        catch (error) {
+            return fail("X Search error", error);
+        }
+    });
+    registerTool(server, apiKey, "web-search", "Web Search", "SERP-style web search using Desearch. Returns ranked titles, links, and snippets.", {
+        query: z.string().describe("Search query, example: 'latest news on AI'"),
+        start: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("How many results to skip for pagination (0, 10, 20, ...). Omit for the first page."),
+    }, async ({ query, start }) => {
+        try {
+            return ok(await desearch.webSearch({ query, start }));
+        }
+        catch (error) {
+            return fail("Web Search error", error);
+        }
+    });
+    registerTool(server, apiKey, "web-links-search", "Web Links Search", "Search the web for links using Desearch. Only the web source is accepted.", {
+        prompt: z
+            .string()
+            .describe("Search query prompt, example: 'open source browser automation tools'"),
+        tools: z
+            .array(toolIdSchema(WEB_LINK_TOOLS))
+            .min(1)
+            .default(["web"])
+            .describe("Sources to search. Only 'web' is accepted; other ids are rejected before the API call. 'Web Search' is accepted and rewritten to 'web'. Defaults to ['web']."),
+        count: z
+            .number()
+            .int()
+            .min(10)
+            .max(200)
+            .optional()
+            .describe("Results to return per source. Min 10. Max 200."),
+    }, async ({ prompt, tools, count }) => {
+        try {
+            return ok(presentSearchBody(await desearch.aiWebLinksSearch({
+                prompt,
+                tools,
+                ...definedFields({ count }),
+            })));
+        }
+        catch (error) {
+            return fail("Web Links Search error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-links-search", "X Links Search", "AI search for X (Twitter) post links using Desearch. Returns links from posts that match the prompt.", {
+        prompt: z.string().describe("Search query prompt, example: 'Bittensor subnet updates'"),
+        count: optionalLinksCount,
+    }, async ({ prompt, count }) => {
+        try {
+            return ok(await desearch.aiXLinksSearch({ prompt, count }));
+        }
+        catch (error) {
+            return fail("X Links Search error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-posts-by-urls", "Get X Posts by URLs", "Fetch full X (Twitter) posts for a list of post URLs.", {
+        urls: z
+            .array(z.string())
+            .min(1)
+            .describe("Post URLs to fetch, example: ['https://x.com/user/status/123']"),
+    }, async ({ urls }) => {
+        try {
+            return ok(await desearch.xPostsByUrls({ urls }));
+        }
+        catch (error) {
+            return fail("X Posts By URLs error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-post-by-id", "Get X Post by ID", "Fetch a single X (Twitter) post by its ID.", {
+        id: z.string().describe("The unique ID of the post, example: '1234567890'"),
+    }, async ({ id }) => {
+        try {
+            return ok(await desearch.xPostById({ id }));
+        }
+        catch (error) {
+            return fail("X Post By ID error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-posts-by-user", "Search X Posts by User", "Search X (Twitter) posts by a specific user, with an optional keyword query.", {
+        user: z.string().describe("User to search for, example: 'elonmusk'"),
+        query: z.string().optional().describe("Advanced search query to filter this user's posts."),
+        count: optionalPostCount,
+    }, async ({ user, query, count }) => {
+        try {
+            return ok(await desearch.xPostsByUser({ user, query, count }));
+        }
+        catch (error) {
+            return fail("X Posts By User error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-post-retweeters", "List X Post Retweeters", "List users who retweeted an X (Twitter) post. Pass cursor to page through more users.", {
+        id: z.string().describe("The ID of the post to get retweeters for."),
+        cursor: z.string().optional().describe("Cursor for pagination from a previous response."),
+    }, async ({ id, cursor }) => {
+        try {
+            return ok(await desearch.xPostRetweeters({ id, cursor }));
+        }
+        catch (error) {
+            return fail("X Post Retweeters error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-user-posts", "Get X User Timeline", "Retrieve a user's X (Twitter) timeline posts by username. Pass cursor to page through more posts.", {
+        username: z.string().describe("Username to fetch posts for, example: 'elonmusk'"),
+        cursor: z.string().optional().describe("Cursor for pagination from a previous response."),
+    }, async ({ username, cursor }) => {
+        try {
+            return ok(await desearch.xUserPosts({ username, cursor }));
+        }
+        catch (error) {
+            return fail("X User Posts error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-user-replies", "Get X User Replies", "Fetch posts and replies by an X (Twitter) user, with an optional keyword query.", {
+        user: z.string().describe("Username of the user to search for, example: 'elonmusk'"),
+        count: optionalPostCount,
+        query: z.string().optional().describe("Advanced search query to filter this user's posts and replies."),
+    }, async ({ user, count, query }) => {
+        try {
+            return ok(await desearch.xUserReplies({ user, count, query }));
+        }
+        catch (error) {
+            return fail("X User Replies error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-post-replies", "Get X Post Replies", "Fetch replies to an X (Twitter) post, with an optional keyword query.", {
+        post_id: z.string().describe("The ID of the post to fetch replies for."),
+        count: optionalPostCount,
+        query: z.string().optional().describe("Advanced search query to filter replies."),
+    }, async ({ post_id, count, query }) => {
+        try {
+            return ok(await desearch.xPostReplies({ post_id, count, query }));
+        }
+        catch (error) {
+            return fail("X Post Replies error", error);
+        }
+    });
+    registerTool(server, apiKey, "extract", "Extract Page Content", "Extract a public URL and return its content as plain text or HTML using Desearch. Preferred over web-crawl for new integrations.", pageContentFields(), async ({ url, format, js, wait }) => {
+        try {
+            return ok(await desearch.extract({ url, format, js, wait }));
+        }
+        catch (error) {
+            return fail("Extract error", error);
+        }
+    });
+    registerTool(server, apiKey, "web-crawl", "Crawl Web Page (Legacy)", "Crawl a public URL and return its content as plain text or HTML on the legacy Desearch /web/crawl route. The SDK marks webCrawl deprecated in favor of extract; this tool stays for parity with that route. Prefer extract for new integrations.", pageContentFields(), async ({ url, format, js, wait }) => {
+        try {
+            return ok(await desearch.webCrawl({ url, format, js, wait }));
+        }
+        catch (error) {
+            return fail("Web Crawl error", error);
+        }
+    });
+    registerTool(server, apiKey, "x-trends", "Get X Trends", "Retrieve trending topics on X (Twitter) for a location by its WOEID using Desearch.", {
+        woeid: z
+            .number()
+            .int()
+            .describe("WOEID of the location, example: 23424977 for the United States."),
+        count: z
+            .number()
+            .int()
+            .min(30)
+            .max(100)
+            .optional()
+            .describe("Number of trends to return (30-100)."),
+    }, async ({ woeid, count }) => {
+        try {
+            return ok(await desearch.xTrends({ woeid, count }));
+        }
+        catch (error) {
+            return fail("X Trends error", error);
+        }
+    });
+    // Scanners ask for these lists during discovery. There is nothing to return,
+    // but an empty list is a successful response. Method-not-found looks like a
+    // broken server to some directory crawlers.
+    server.server.registerCapabilities({
+        prompts: {},
+        resources: {},
+    });
+    server.server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: [] }));
+    server.server.setRequestHandler(ListResourcesRequestSchema, () => ({ resources: [] }));
+    server.server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
+        resourceTemplates: [],
+    }));
+    return server;
+}

package/build/tool-sources.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+/**
+ * Short source ids shared by ai-search and web-links-search.
+ *
+ * Wire values are the short ids from live OpenAPI
+ * (https://api.desearch.ai/openapi.json, checked 2026-10-01) and from
+ * desearch-js `ToolEnum` / `WebToolEnum`. Display labels such as "Web Search"
+ * are the previous ai-search schema. They are accepted here and rewritten to
+ * the short id before the Desearch call.
+ *
+ * Live OpenAPI names a narrower set than desearch-js 1.5:
+ * - `ToolEnum` (`POST /desearch/ai/search`): `web`, `twitter`. Items are
+ *   `ToolEnum | string`, and the previous MCP tool already offered the other
+ *   desearch-js sources under display labels. Those stay, spelled as short ids.
+ *   PR #13 did not see a 422 for this route.
+ * - `WebToolEnum` (`POST /desearch/ai/search/links/web`): `web` only. The other
+ *   short ids 422 (`supported tools are Web Search`). `WEB_LINK_TOOLS` is
+ *   `["web"]` so the MCP enum does not offer ids the route rejects.
+ *   `"Web Search"` still rewrites to `web`.
+ */
+export declare const AI_SEARCH_TOOLS: readonly ["web", "twitter", "arxiv", "wikipedia", "youtube", "hackernews", "reddit"];
+export declare const WEB_LINK_TOOLS: readonly ["web"];
+/** Previous ai-search labels. Not advertised in the JSON Schema enum. */
+export declare const LEGACY_DISPLAY_TO_ID: Readonly<Record<string, string>>;
+export declare function canonicalToolId(value: string): string;
+type NonEmptyIds = readonly [string, ...string[]];
+/**
+ * JSON Schema enum is the short ids. Zod still accepts a legacy display label
+ * and replaces it with the short id the API examples and SDKs send.
+ */
+export declare function toolIdSchema<T extends NonEmptyIds>(ids: T): z.ZodEffects<z.ZodEnum<[string, ...string[]]>, string, unknown>;
+export {};
+//# sourceMappingURL=tool-sources.d.ts.map

package/build/tool-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-sources.d.ts","sourceRoot":"","sources":["../tool-sources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,sFAQlB,CAAC;AAEX,eAAO,MAAM,cAAc,kBAAmB,CAAC;AAE/C,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQjE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,KAAK,WAAW,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;AAElD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,mEAKzD"}

package/build/tool-sources.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+/**
+ * Short source ids shared by ai-search and web-links-search.
+ *
+ * Wire values are the short ids from live OpenAPI
+ * (https://api.desearch.ai/openapi.json, checked 2026-10-01) and from
+ * desearch-js `ToolEnum` / `WebToolEnum`. Display labels such as "Web Search"
+ * are the previous ai-search schema. They are accepted here and rewritten to
+ * the short id before the Desearch call.
+ *
+ * Live OpenAPI names a narrower set than desearch-js 1.5:
+ * - `ToolEnum` (`POST /desearch/ai/search`): `web`, `twitter`. Items are
+ *   `ToolEnum | string`, and the previous MCP tool already offered the other
+ *   desearch-js sources under display labels. Those stay, spelled as short ids.
+ *   PR #13 did not see a 422 for this route.
+ * - `WebToolEnum` (`POST /desearch/ai/search/links/web`): `web` only. The other
+ *   short ids 422 (`supported tools are Web Search`). `WEB_LINK_TOOLS` is
+ *   `["web"]` so the MCP enum does not offer ids the route rejects.
+ *   `"Web Search"` still rewrites to `web`.
+ */
+export const AI_SEARCH_TOOLS = [
+    "web",
+    "twitter",
+    "arxiv",
+    "wikipedia",
+    "youtube",
+    "hackernews",
+    "reddit",
+];
+export const WEB_LINK_TOOLS = ["web"];
+/** Previous ai-search labels. Not advertised in the JSON Schema enum. */
+export const LEGACY_DISPLAY_TO_ID = {
+    "Web Search": "web",
+    "Twitter Search": "twitter",
+    "ArXiv Search": "arxiv",
+    "Wikipedia Search": "wikipedia",
+    "Youtube Search": "youtube",
+    "Hacker News Search": "hackernews",
+    "Reddit Search": "reddit",
+};
+export function canonicalToolId(value) {
+    return LEGACY_DISPLAY_TO_ID[value] ?? value;
+}
+/**
+ * JSON Schema enum is the short ids. Zod still accepts a legacy display label
+ * and replaces it with the short id the API examples and SDKs send.
+ */
+export function toolIdSchema(ids) {
+    return z.preprocess((value) => (typeof value === "string" ? canonicalToolId(value) : value), z.enum(ids));
+}

package/package.json

@@ -1,7 +1,10 @@
 {
     "name": "desearch-mcp-server",
-    "version": "0.0.1",
-    "description": "A Model Context Protocol server with Desearch for real-time AI search, X search and web search.",
+    "version": "0.1.3",
+    "mcpName": "io.github.Desearch-ai/mcp-desearch",
+    "description": "AI search, X search and web search for AI agents, plus page extraction and X data tools. Bring your own Desearch API key.",
+    "license": "MIT",
+    "homepage": "https://www.desearch.ai/docs/guide/sdk/mcp",
     "type": "module",
     "author": "Desearch AI",
     "repository": {
@@ -12,7 +15,8 @@
         "desearch-mcp-server": "./build/index.js"
     },
     "files": [
-        "build"
+        "build",
+        "CHANGELOG.md"
     ],
     "keywords": [
         "desearch",
@@ -25,13 +29,16 @@
     ],
     "scripts": {
         "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+        "start:http": "node build/index.js --http",
+        "test": "npm run build && node --test test/*.test.mjs",
         "inspector": "npx @modelcontextprotocol/inspector build/index.js",
         "prepare": "npm run build",
         "prepublishOnly": "npm run build"
     },
     "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.11.3",
-        "desearch-js": "^1.0.1",
+        "@modelcontextprotocol/sdk": "^1.30.1",
+        "desearch-js": "^1.5.0",
+        "undici": "^7.29.1",
         "zod": "^3.24.4"
     },
     "devDependencies": {
@@ -39,6 +46,9 @@
         "typescript": "^5.8.3"
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.18.1"
+    },
+    "overrides": {
+        "undici": "$undici"
     }
 }