@kinginsun/mcp-drugsea 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kinginsun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# mcp-drugsea
+
+MCP (Model Context Protocol) stdio server for [DrugSea / Yaohai](https://db.drugsea.cn) pharmaceutical databases.
+
+The server forwards tool calls to `https://api2.drugsea.cn` with header `X-Yaohai-Api-Key`. It covers:
+
+- **yaohai-*** — cross-database catalog / search / detail / global / smart-search (`POST /g/mcp/yaohai/*`)
+- **product-cn-*** — already-marketed China products (`GET /product/cn/...`)
+- **reg-cn-*** — CDE registration / review pipeline (`GET /b/drugreg/cn/...` and facet prefix `/b/es/drugreg/cn/list`)
+
+**GitHub:** [github.com/kinginsun/mcp-drugsea](https://github.com/kinginsun/mcp-drugsea)
+
+## Installation
+
+```bash
+npm install -g @kinginsun/mcp-drugsea
+```
+
+Or run without installing:
+
+```bash
+npx -y @kinginsun/mcp-drugsea
+```
+
+## Configuration
+
+### `YAOHAI_MCP_API_KEY` (required)
+
+The server accepts either:
+
+| Credential | Format | HTTP header |
+|------------|--------|-------------|
+| Shared MCP key | opaque string (server env `YAOHAI_MCP_API_KEY`) | `X-Yaohai-Api-Key` |
+| Personal user token | `ysk_` + 32 hex chars | `Authorization: Bearer ysk_…` |
+
+This client auto-selects the header from the value shape. You may set `YAOHAI_MCP_TOKEN` instead of `YAOHAI_MCP_API_KEY` for a user token.
+
+**Note:** Production MCP with personal `ysk_` tokens is deployed at **`https://db3.drugsea.cn/api/g/mcp/*`**. Legacy `api2.drugsea.cn` accepts only the shared `X-Yaohai-Api-Key`. On db3, direct GET list/facet routes return encrypted payloads; this client auto-routes `product-cn-search` / `reg-cn-search` / detail through MCP POST when the base URL contains `db3.drugsea.cn`.
+
+Obtain a key from the DrugSea / Yaohai operator, then:
+
+```bash
+export YAOHAI_MCP_API_KEY=your_api_key_here
+```
+
+### Optional
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `YAOHAI_BASE_URL` | `https://db3.drugsea.cn/api` | API origin (no trailing slash). MCP: `/g/mcp/yaohai/*` |
+| `YAOHAI_VERIFY_SSL` | `true` | Set `false` / `0` / `off` to skip TLS certificate verification (needed on some prod hosts) |
+| `YAOHAI_USE_MCP_LIST` | auto on db3 | Force product/reg search via MCP POST instead of GET |
+
+### Cursor MCP (`~/.cursor/mcp.json`)
+
+```json
+{
+  "mcpServers": {
+    "drugsea": {
+      "command": "npx",
+      "args": ["-y", "@kinginsun/mcp-drugsea"],
+      "env": {
+        "YAOHAI_MCP_API_KEY": "your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+  "mcpServers": {
+    "drugsea": {
+      "command": "npx",
+      "args": ["-y", "@kinginsun/mcp-drugsea"],
+      "env": {
+        "YAOHAI_MCP_API_KEY": "your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+## Which tools to use
+
+| User intent | Tools |
+|-------------|--------|
+| Already listed in China (国药准字, 批准文号, 上市, 医保/集采状态) | `product-cn-fields` → `product-cn-search` / `product-cn-facets` → `product-cn-detail` |
+| R&D / CDE (在研, 受理号, 审评, 尚未上市) | `reg-cn-fields` → `reg-cn-search` / `reg-cn-facets` → `reg-cn-detail` |
+| Other DBs (医保 `yibao`, 基药 `jiyao`, 集采 `jicai`, trials, DMF, …) | `yaohai-catalog` → `yaohai-search` → `yaohai-detail` |
+| Global panorama | `yaohai-global-search` |
+| Unclear which DB | `yaohai-smart-search` |
+
+Therapeutic-class queries (抗癌, 心血管, …): prefer ConditionSearch `ATC_code` (letter, e.g. `L` oncology, `C` cardiovascular, `J` anti-infectives, `N` nervous system). Confirm values with a facets tool when unsure.
+
+If `total > 20`, summarize in chat (about 5–10 sample rows) instead of pasting the full table.
+
+xlsx export is not implemented in this MCP (v1 returns JSON samples only).
+
+`product-cn-*` and `reg-cn-*` list/facet/detail calls use the same GET routes as the website. Some API2 deployments IP-allowlist those paths and respond with `非法IP地址`. The `yaohai-*` tools use `POST /g/mcp/yaohai/*`, which is the MCP-keyed surface and is not subject to that list GET allowlist.
+
+## Tools
+
+### Yaohai (cross-DB)
+
+| Tool | Parameters | Notes |
+|------|------------|--------|
+| `yaohai-catalog` | `category?`, `q?` | List databases |
+| `yaohai-search` | `dbname`, `query?`, `limit?`, `offset?` | Default limit 10, max 50 |
+| `yaohai-detail` | `dbname`, `id` | Skip DBs with `has_detail: false` |
+| `yaohai-global-search` | `q?`, `query?`, `limit?`, `offset?` | `q` fills `query.term` |
+| `yaohai-smart-search` | `q`, `query?`, `limit?` | Auto-routes up to 3 DBs |
+
+### product_cn (marketed)
+
+| Tool | Parameters | Notes |
+|------|------------|--------|
+| `product-cn-fields` | _(none)_ | Local field catalog |
+| `product-cn-search` | `query?`, `limit?`, `offset?`, `view_type?` | Default `search_mode=3`; limit default 20, max 100 |
+| `product-cn-facets` | `query?`, `facets` (required) | Do not request all 22 dimensions. Recommended: `ATC_code`, `drug_type`, `national_yibao`, `std_dosage_form`, `source` |
+| `product-cn-detail` | `id` | Encrypted id from search rows |
+
+`first_approve_date` is first listing date; `approve_date` is latest re-registration (not first listing).
+
+`view_type`: `eslist` (default) / `list_by_drug_name` / `list_by_manufacture`.
+
+### reg_cn (CDE review)
+
+| Tool | Parameters | Notes |
+|------|------------|--------|
+| `reg-cn-fields` | _(none)_ | Local field catalog |
+| `reg-cn-search` | `query?`, `limit?`, `offset?`, `view_type?` | Default `rows_excluded=1`, `search_mode=1`; limit default 20, max 100 |
+| `reg-cn-facets` | `query?`, `facets` (required) | Recommended: `ATC_code`, `rd_status`, `drug_type`, `transact_status`, `register_type` |
+| `reg-cn-detail` | `id` | Encrypted id from search rows |
+
+`view_type`: `eslist` (default) / `list_by_drug_name` / `list_by_enterprise`.
+
+`query` values may be string, number, or string arrays (ConditionSearch `multiple`). Dates: `"YYYY-MM-DD to YYYY-MM-DD"`. Ranges: `"min to max"`.
+
+## Manual stdio test
+
+```bash
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' \
+  | YAOHAI_MCP_API_KEY=your_key node dist/index.js
+```
+
+```bash
+echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"yaohai-catalog","arguments":{"q":"医保"}}}' \
+  | YAOHAI_MCP_API_KEY=your_key node dist/index.js
+```
+
+```bash
+echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"product-cn-search","arguments":{"query":{"drug_name":"阿司匹林"},"limit":3}}}' \
+  | YAOHAI_MCP_API_KEY=your_key node dist/index.js
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## License
+
+MIT

package/dist/api.js

@@ -0,0 +1,331 @@
+import http from "node:http";
+import https from "node:https";
+import { URL } from "node:url";
+import { normalizeRecord, parseFacetList } from "./normalize.js";
+export class MissingApiKeyError extends Error {
+    constructor() {
+        super("Set YAOHAI_MCP_API_KEY (shared key) or YAOHAI_MCP_TOKEN (ysk_… user token)");
+        this.name = "MissingApiKeyError";
+    }
+}
+export class ApiError extends Error {
+    status;
+    raw;
+    constructor(message, status = 0, raw) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.raw = raw;
+    }
+}
+export function getApiKey() {
+    const token = process.env.YAOHAI_MCP_TOKEN?.trim() || "";
+    const key = process.env.YAOHAI_MCP_API_KEY?.trim() || "";
+    const value = token || key;
+    if (!value) {
+        throw new MissingApiKeyError();
+    }
+    return value;
+}
+/** Shared server key → X-Yaohai-Api-Key; user token ysk_… → Authorization Bearer. */
+export function getAuthHeaders(extra = {}) {
+    const credential = getApiKey();
+    const headers = { ...extra };
+    if (credential.startsWith("ysk_")) {
+        headers.Authorization = `Bearer ${credential}`;
+    }
+    else {
+        headers["X-Yaohai-Api-Key"] = credential;
+    }
+    return headers;
+}
+export function getBaseUrl() {
+    return (process.env.YAOHAI_BASE_URL || "https://db3.drugsea.cn/api").replace(/\/$/, "");
+}
+/** db3 serves list/facet GET as encrypted payloads; use POST /g/mcp/yaohai/search instead. */
+export function prefersMcpListApi() {
+    const flag = process.env.YAOHAI_USE_MCP_LIST?.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(flag ?? "")) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(flag ?? "")) {
+        return false;
+    }
+    return getBaseUrl().includes("db3.drugsea.cn");
+}
+export function getVerifySsl() {
+    const v = process.env.YAOHAI_VERIFY_SSL;
+    if (v === undefined || v === "") {
+        return true;
+    }
+    return !["0", "false", "no", "off"].includes(v.trim().toLowerCase());
+}
+export function flattenQuery(params) {
+    const sp = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === null || v === "") {
+            continue;
+        }
+        if (Array.isArray(v)) {
+            for (const item of v) {
+                sp.append(k, String(item));
+            }
+        }
+        else if (typeof v === "boolean") {
+            sp.append(k, v ? "1" : "0");
+        }
+        else {
+            sp.append(k, String(v));
+        }
+    }
+    return sp;
+}
+export function clampLimit(limit, fallback, max) {
+    const n = limit ?? fallback;
+    if (!Number.isFinite(n)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(Math.trunc(n), max));
+}
+export function clampOffset(offset) {
+    if (offset === undefined || !Number.isFinite(offset)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(offset));
+}
+function httpRequest(method, urlStr, headers, body) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(urlStr);
+        const lib = url.protocol === "https:" ? https : http;
+        const options = {
+            method,
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: `${url.pathname}${url.search}`,
+            headers,
+            timeout: 60_000,
+        };
+        if (url.protocol === "https:" && !getVerifySsl()) {
+            options.agent = new https.Agent({ rejectUnauthorized: false });
+        }
+        const req = lib.request(options, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            res.on("end", () => {
+                resolve({
+                    status: res.statusCode ?? 0,
+                    text: Buffer.concat(chunks).toString("utf8"),
+                });
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy(new Error("API request timed out after 60s"));
+        });
+        req.on("error", reject);
+        if (body) {
+            req.write(body);
+        }
+        req.end();
+    });
+}
+function parseApiJson(status, text) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status,
+            error: `Failed to parse API response: ${String(error)}`,
+        };
+    }
+    if (data &&
+        typeof data === "object" &&
+        "data" in data &&
+        !("api_status" in data)) {
+        return {
+            ok: false,
+            status,
+            error: "Encrypted or non-JSON API payload (db3 list/facet GET). Use YAOHAI_BASE_URL=https://db3.drugsea.cn/api so product-cn-search/reg-cn-search route via MCP POST, or set YAOHAI_USE_MCP_LIST=true.",
+            raw: data,
+        };
+    }
+    if (status < 200 || status >= 300) {
+        return {
+            ok: false,
+            status,
+            error: `API request failed with status ${status}: ${JSON.stringify(data)}`,
+            raw: data,
+        };
+    }
+    if (data &&
+        typeof data === "object" &&
+        "api_status" in data &&
+        data.api_status !== "success") {
+        const payload = data;
+        const content = payload.content;
+        const message = typeof content === "string" ? content : JSON.stringify(content ?? data);
+        return { ok: false, status, error: message, raw: data };
+    }
+    const content = data && typeof data === "object" && "content" in data
+        ? data.content
+        : data;
+    return {
+        ok: true,
+        status,
+        content,
+        raw: (data && typeof data === "object"
+            ? data
+            : { content: data }),
+    };
+}
+function unwrap(result) {
+    if (!result.ok) {
+        throw new ApiError(result.error, result.status, result.raw);
+    }
+    return result.content;
+}
+export async function yaohaiPost(path, body) {
+    const payload = JSON.stringify(body);
+    const url = `${getBaseUrl()}${path}`;
+    const { status, text } = await httpRequest("POST", url, getAuthHeaders({
+        "Content-Type": "application/json",
+        "Content-Length": String(Buffer.byteLength(payload)),
+    }), payload);
+    return unwrap(parseApiJson(status, text));
+}
+export async function yaohaiGet(path, query = {}) {
+    const qs = flattenQuery(query).toString();
+    const url = `${getBaseUrl()}${path}${qs ? `?${qs}` : ""}`;
+    const { status, text } = await httpRequest("GET", url, getAuthHeaders());
+    return parseApiJson(status, text);
+}
+export async function mcpDbSearch(opts) {
+    const query = { ...opts.query };
+    if (opts.viewType && opts.viewType !== "eslist") {
+        query.view_type = opts.viewType;
+    }
+    const content = (await yaohaiPost("/g/mcp/yaohai/search", {
+        dbname: opts.dbname,
+        query,
+        limit: opts.limit,
+        offset: opts.offset,
+    }));
+    const rawItems = content.items;
+    const items = Array.isArray(rawItems)
+        ? rawItems.map((item) => {
+            if (item && typeof item === "object" && "fields" in item) {
+                const row = item;
+                const flat = normalizeRecord(row.fields);
+                if (row.detail_url &&
+                    flat &&
+                    typeof flat === "object" &&
+                    !Array.isArray(flat)) {
+                    return { ...flat, detail_url: row.detail_url };
+                }
+                return flat;
+            }
+            return normalizeRecord(item);
+        })
+        : rawItems;
+    return {
+        dbname: content.dbname,
+        title: content.title,
+        category: content.category,
+        view_type: opts.viewType ?? "eslist",
+        total: content.total,
+        offset: opts.offset,
+        limit: opts.limit,
+        count: Array.isArray(items) ? items.length : undefined,
+        items,
+        query_applied: opts.query,
+        field_labels: content.field_labels,
+        via: "mcp",
+    };
+}
+export async function mcpDbDetail(dbname, id) {
+    const content = (await yaohaiPost("/g/mcp/yaohai/detail", {
+        dbname,
+        id,
+    }));
+    return { dbname, id, ...content };
+}
+export async function listSearch(opts) {
+    const params = {
+        ...opts.query,
+        limit: opts.limit,
+        offset: opts.offset,
+    };
+    const result = await yaohaiGet(opts.path, params);
+    if (!result.ok) {
+        throw new ApiError(result.error, result.status, result.raw);
+    }
+    const raw = result.raw;
+    const content = raw.content ?? result.content;
+    const items = normalizeRecord(content);
+    const totalRaw = raw.tnum;
+    const total = typeof totalRaw === "number"
+        ? totalRaw
+        : Array.isArray(items)
+            ? items.length
+            : 0;
+    return {
+        view_type: opts.viewType,
+        total,
+        offset: opts.offset,
+        limit: opts.limit,
+        count: Array.isArray(items) ? items.length : undefined,
+        items,
+        query_applied: opts.query,
+    };
+}
+export async function fetchDetail(path, id) {
+    const result = await yaohaiGet(path, {});
+    if (!result.ok) {
+        throw new ApiError(result.error, result.status, result.raw);
+    }
+    return {
+        id,
+        detail: normalizeRecord(result.content),
+    };
+}
+export async function fetchFacets(opts) {
+    const unknown = opts.fields.filter((f) => !(f in opts.catalog));
+    if (unknown.length > 0) {
+        throw new ApiError(`Unknown facet fields: ${unknown.join(", ")}`);
+    }
+    const distributions = {};
+    for (const field of opts.fields) {
+        const meta = opts.catalog[field];
+        const facetQuery = { ...opts.query };
+        delete facetQuery[field];
+        const result = await yaohaiGet(`${opts.prefix}/${encodeURIComponent(field)}`, facetQuery);
+        if (!result.ok) {
+            distributions[field] = {
+                success: false,
+                error: result.error,
+                title: meta.title,
+            };
+            continue;
+        }
+        const data = isRecord(result.content) ? result.content : {};
+        const list = data.list;
+        distributions[field] = {
+            success: true,
+            title: meta.title,
+            filter_type: data.type ?? meta.filter_type,
+            items: parseFacetList(list, field),
+        };
+    }
+    return {
+        query_applied: opts.query,
+        total_fields: opts.fields.length,
+        distributions,
+    };
+}
+function isRecord(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}

package/dist/fields.js

@@ -0,0 +1,116 @@
+export const PRODUCT_CN_COMMON_FIELDS = [
+    "item",
+    "drug_name",
+    "manufacture",
+    "license_holder",
+    "specification",
+    "std_specification",
+    "auth_num",
+    "indication",
+    "general_name_cn",
+    "only_active",
+    "search_mode",
+];
+export const PRODUCT_CN_FACET_FIELDS = {
+    listing_date: { title: "上市年份", filter_type: "multiple" },
+    source: { title: "国产进口", filter_type: "multiple" },
+    province: { title: "省份", filter_type: "multiple" },
+    drug_type: { title: "药品类型", filter_type: "multiple" },
+    register_type: { title: "注册分类", filter_type: "multiple" },
+    national_yibao: { title: "医保类型", filter_type: "multiple" },
+    national_jiyao: { title: "基药类型", filter_type: "multiple" },
+    state_OTC: { title: "非处方药", filter_type: "multiple" },
+    std_dosage_form: { title: "药品剂型", filter_type: "multiple" },
+    administration_route: { title: "给药途径", filter_type: "multiple" },
+    new_drug_type: { title: "新药类型", filter_type: "multiple" },
+    ATC_code: { title: "ATC分类", filter_type: "multiple" },
+    is_orange_book: { title: "目录集收录", filter_type: "multiple" },
+    is_passed_yizhi: { title: "通过一致性评价", filter_type: "multiple" },
+    is_guojia_jicai: { title: "是否已国家集采", filter_type: "multiple" },
+    related_jc_projects: { title: "国家集采相关项目", filter_type: "multiple" },
+    approve_date: { title: "最近再注册批准日期", filter_type: "date" },
+    first_approve_date: { title: "品种首次上市日期", filter_type: "date" },
+    general_name_count: { title: "同成分厂家数", filter_type: "range" },
+    product_count: { title: "同品种厂家数", filter_type: "range" },
+    dosage_count: { title: "同规格厂家数", filter_type: "range" },
+    in_sfda: { title: "是否有效", filter_type: "multiple" },
+};
+export const PRODUCT_CN_VIEW_TYPES = [
+    "eslist",
+    "list_by_drug_name",
+    "list_by_manufacture",
+];
+export const REG_CN_COMMON_FIELDS = [
+    "item",
+    "drug_name",
+    "enterprise",
+    "slh",
+    "indication",
+    "rows_excluded",
+    "search_mode",
+];
+export const REG_CN_FACET_FIELDS = {
+    rd_status: { title: "研发状态", filter_type: "multiple" },
+    innovation_degree: { title: "创新程度", filter_type: "multiple" },
+    first_generic_drug: { title: "首仿状态", filter_type: "multiple" },
+    apply_type: { title: "申请类型", filter_type: "multiple" },
+    conclusion: { title: "审评结论", filter_type: "multiple" },
+    transact_status: { title: "办理状态", filter_type: "multiple" },
+    register_type: { title: "注册分类", filter_type: "multiple" },
+    special_list: { title: "特殊品种", filter_type: "multiple" },
+    applyTypeCde: { title: "审评序列", filter_type: "multiple" },
+    drug_type: { title: "药品类型", filter_type: "multiple" },
+    drug_category: { title: "药品小类", filter_type: "multiple" },
+    std_dosage_form: { title: "药品剂型", filter_type: "multiple" },
+    yibao_dosage: { title: "医保剂型", filter_type: "multiple" },
+    administration_route: { title: "给药途径", filter_type: "multiple" },
+    slh_types: { title: "申报类型", filter_type: "multiple" },
+    ATC_code: { title: "ATC一级分类", filter_type: "multiple" },
+    provinces: { title: "来源省份", filter_type: "multiple" },
+    undertake_date: { title: "承办日期", filter_type: "date" },
+    status_start_date: { title: "状态日期", filter_type: "date" },
+    apply_ctc_num: { title: "申报临床厂家数", filter_type: "range" },
+    apply_listing_num: { title: "申报生产厂家数", filter_type: "range" },
+    market_num: { title: "已上市厂家数", filter_type: "range" },
+};
+export const REG_CN_VIEW_TYPES = [
+    "eslist",
+    "list_by_drug_name",
+    "list_by_enterprise",
+];
+export const PRODUCT_CN_SEARCH_PATH = "/product/cn/eslist";
+export const PRODUCT_CN_DETAIL_PATH = "/product/cn/detail";
+export const PRODUCT_CN_FACET_PREFIX = "/product/cn/eslist";
+export const REG_CN_SEARCH_PATH = "/b/drugreg/cn/eslist";
+export const REG_CN_DETAIL_PATH = "/b/drugreg/cn/detail";
+export const REG_CN_FACET_PREFIX = "/b/es/drugreg/cn/list";
+export const ATC_HINT = "For disease/therapeutic-class queries prefer ConditionSearch ATC_code (letter): L=oncology, C=cardiovascular, J=anti-infectives, N=nervous system, R=respiratory, A=alimentary/metabolism (e.g. diabetes), H=hormones, G=genito-urinary, M=musculo-skeletal, D=dermatologicals, B=blood, S=sensory, P=antiparasitic, V=various.";
+export function productCnSearchPath(viewType) {
+    if (viewType === "eslist") {
+        return PRODUCT_CN_SEARCH_PATH;
+    }
+    return `/product/cn/${viewType}`;
+}
+export function regCnSearchPath(viewType) {
+    if (viewType === "eslist") {
+        return REG_CN_SEARCH_PATH;
+    }
+    return `/b/drugreg/cn/${viewType}`;
+}
+export function applyProductCnDefaults(query) {
+    const merged = { ...query };
+    if (merged.search_mode === undefined || merged.search_mode === "") {
+        merged.search_mode = "3";
+    }
+    return merged;
+}
+export function applyRegCnDefaults(query) {
+    const merged = { ...query };
+    if (merged.rows_excluded === undefined || merged.rows_excluded === "") {
+        merged.rows_excluded = 1;
+    }
+    if (merged.search_mode === undefined || merged.search_mode === "") {
+        merged.search_mode = "1";
+    }
+    return merged;
+}

package/dist/index.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { clampLimit, clampOffset, fetchDetail, fetchFacets, listSearch, mcpDbDetail, mcpDbSearch, prefersMcpListApi, yaohaiPost, } from "./api.js";
+import { ATC_HINT, PRODUCT_CN_COMMON_FIELDS, PRODUCT_CN_DETAIL_PATH, PRODUCT_CN_FACET_FIELDS, PRODUCT_CN_FACET_PREFIX, PRODUCT_CN_VIEW_TYPES, REG_CN_COMMON_FIELDS, REG_CN_DETAIL_PATH, REG_CN_FACET_FIELDS, REG_CN_FACET_PREFIX, REG_CN_VIEW_TYPES, applyProductCnDefaults, applyRegCnDefaults, productCnSearchPath, regCnSearchPath, } from "./fields.js";
+import { EmptyObjectSchema, ProductCnDetailSchema, ProductCnFacetsSchema, ProductCnSearchSchema, RegCnDetailSchema, RegCnFacetsSchema, RegCnSearchSchema, YaohaiCatalogSchema, YaohaiDetailSchema, YaohaiGlobalSearchSchema, YaohaiSearchSchema, YaohaiSmartSearchSchema, } from "./types.js";
+const PACKAGE_VERSION = "0.1.0";
+const YAOHAI_LIMIT_MAX = 50;
+const YAOHAI_LIMIT_DEFAULT = 10;
+const CN_LIMIT_MAX = 100;
+const CN_LIMIT_DEFAULT = 20;
+const QUERY_PROP = {
+    type: "object",
+    additionalProperties: true,
+    description: "Search/filter fields. Values may be string, number, or string[] (repeat the key for ConditionSearch multiple). Date: \"YYYY-MM-DD to YYYY-MM-DD\". Range: \"min to max\".",
+};
+const PRESENTATION_HINT = "If total > 20, summarize in chat (about 5–10 sample rows) instead of dumping the full table. Include frontend source links when present.";
+const ROUTING_HINT = "Already-marketed China products (国药准字, 批准文号, 上市, 医保/集采) → product-cn-* tools. R&D / CDE pipeline (在研, 受理号, 审评, 尚未上市) → reg-cn-* tools. Other DBs (医保 yibao, 基药 jiyao, 集采 jicai, trials, global) → yaohai-*. Do not use yaohai-search with dbname product_cn or reg_cn when the dedicated tools apply.";
+process.on("uncaughtException", (error) => {
+    console.error("Uncaught Exception:", error);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    process.exit(1);
+});
+const server = new Server({
+    name: "mcp-drugsea",
+    version: PACKAGE_VERSION,
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "yaohai-catalog",
+                description: "List Yaohai / DrugSea databases (60+). Filter by category or keyword to pick a dbname for yaohai-search. " +
+                    ROUTING_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: {
+                            type: "string",
+                            description: "Optional category, e.g. 市场准入, 上市情报, 注册情报, 临床试验, NMPA基础库",
+                        },
+                        q: {
+                            type: "string",
+                            description: "Optional keyword filter on title, id, or keywords",
+                        },
+                    },
+                },
+            },
+            {
+                name: "yaohai-search",
+                description: "Search a single Yaohai database by dbname (from yaohai-catalog). Default limit 10, max 50. " +
+                    "Use query fields from the catalog's search_fields. " +
+                    ROUTING_HINT +
+                    " " +
+                    PRESENTATION_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dbname: {
+                            type: "string",
+                            description: "Database id, e.g. yibao, jiyao, jicai, jicai_mulu, fda_dmf. Prefer product-cn-search / reg-cn-search instead of product_cn / reg_cn.",
+                        },
+                        query: QUERY_PROP,
+                        limit: {
+                            type: "number",
+                            description: `Row cap (default ${YAOHAI_LIMIT_DEFAULT}, max ${YAOHAI_LIMIT_MAX})`,
+                        },
+                        offset: { type: "number", description: "Pagination offset (default 0)" },
+                    },
+                    required: ["dbname"],
+                },
+            },
+            {
+                name: "yaohai-detail",
+                description: "Fetch one record's detail from a Yaohai database. Requires dbname + encrypted id from yaohai-search items. Skip if catalog says has_detail is false (use list fields instead).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dbname: { type: "string", description: "Database id" },
+                        id: { type: "string", description: "Record id from search results" },
+                    },
+                    required: ["dbname", "id"],
+                },
+            },
+            {
+                name: "yaohai-global-search",
+                description: "Global drug panorama search (global_search). Pass q as the search term, or query.term. " +
+                    PRESENTATION_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        q: { type: "string", description: "Search term (maps to query.term)" },
+                        query: QUERY_PROP,
+                        limit: {
+                            type: "number",
+                            description: `Row cap (default ${YAOHAI_LIMIT_DEFAULT}, max ${YAOHAI_LIMIT_MAX})`,
+                        },
+                        offset: { type: "number", description: "Pagination offset (default 0)" },
+                    },
+                },
+            },
+            {
+                name: "yaohai-smart-search",
+                description: "Natural-language Yaohai search: auto-routes the question to up to 3 databases. Use when the user question is broad or the target DB is unclear. " +
+                    ROUTING_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        q: { type: "string", description: "Natural language question" },
+                        query: QUERY_PROP,
+                        limit: {
+                            type: "number",
+                            description: `Row cap (default ${YAOHAI_LIMIT_DEFAULT}, max ${YAOHAI_LIMIT_MAX})`,
+                        },
+                    },
+                    required: ["q"],
+                },
+            },
+            {
+                name: "product-cn-fields",
+                description: "List CommonSearch and ConditionSearch field keys for 国内上市药品 (product_cn). Call before product-cn-search / product-cn-facets if unsure which filters exist.",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "product-cn-search",
+                description: "Search already-marketed China drugs (product_cn / 国药准字 / 批准文号 / NMPA listed). " +
+                    "Default search_mode=3 (partial). first_approve_date = first listing date; approve_date = latest re-registration (not first listing). " +
+                    ATC_HINT +
+                    " Default limit 20, max 100. " +
+                    "Not for R&D pipeline — use reg-cn-search. " +
+                    PRESENTATION_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            ...QUERY_PROP,
+                            description: QUERY_PROP.description +
+                                " Common: item, drug_name, manufacture, license_holder, specification, std_specification, auth_num, indication, general_name_cn, only_active (1), search_mode (1/2/3). Condition examples: ATC_code, national_yibao, std_dosage_form, source, first_approve_date.",
+                        },
+                        limit: {
+                            type: "number",
+                            description: `Row cap (default ${CN_LIMIT_DEFAULT}, max ${CN_LIMIT_MAX})`,
+                        },
+                        offset: { type: "number", description: "Pagination offset (default 0)" },
+                        view_type: {
+                            type: "string",
+                            enum: [...PRODUCT_CN_VIEW_TYPES],
+                            description: "eslist (by approval, default), list_by_drug_name, list_by_manufacture",
+                        },
+                    },
+                },
+            },
+            {
+                name: "product-cn-facets",
+                description: "Facet distributions for 国内上市药品 after a keyword query. facets is required (do not request all 22 — slow). " +
+                    "Recommended: ATC_code, drug_type, national_yibao, std_dosage_form, source. " +
+                    ATC_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: QUERY_PROP,
+                        facets: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Facet field keys to fetch. Recommended: ATC_code, drug_type, national_yibao, std_dosage_form, source.",
+                        },
+                    },
+                    required: ["facets"],
+                },
+            },
+            {
+                name: "product-cn-detail",
+                description: "Detail for one product_cn row. id is the encrypted id from product-cn-search items (not the raw 批准文号).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Encrypted record id from search results" },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "reg-cn-fields",
+                description: "List CommonSearch and ConditionSearch field keys for 药品注册审评 (reg_cn / CDE). Call before reg-cn-search / reg-cn-facets if unsure which filters exist.",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "reg-cn-search",
+                description: "Search China drug registration / CDE review (reg_cn): 在研, 受理号, 申报, 审评进度, not-yet-listed. " +
+                    "Default rows_excluded=1 (drop 备案), search_mode=1. " +
+                    ATC_HINT +
+                    " Default limit 20, max 100. Not for already-marketed products — use product-cn-search. " +
+                    PRESENTATION_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            ...QUERY_PROP,
+                            description: QUERY_PROP.description +
+                                " Common: item, drug_name, enterprise, slh, indication, rows_excluded, search_mode. Condition examples: ATC_code, rd_status, transact_status, register_type, drug_type, undertake_date.",
+                        },
+                        limit: {
+                            type: "number",
+                            description: `Row cap (default ${CN_LIMIT_DEFAULT}, max ${CN_LIMIT_MAX})`,
+                        },
+                        offset: { type: "number", description: "Pagination offset (default 0)" },
+                        view_type: {
+                            type: "string",
+                            enum: [...REG_CN_VIEW_TYPES],
+                            description: "eslist (default), list_by_drug_name, list_by_enterprise",
+                        },
+                    },
+                },
+            },
+            {
+                name: "reg-cn-facets",
+                description: "Facet distributions for 药品注册审评. facets is required (do not request all dimensions — slow). " +
+                    "Recommended: ATC_code, rd_status, drug_type, transact_status, register_type. " +
+                    ATC_HINT,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: QUERY_PROP,
+                        facets: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Facet field keys to fetch. Recommended: ATC_code, rd_status, drug_type, transact_status, register_type.",
+                        },
+                    },
+                    required: ["facets"],
+                },
+            },
+            {
+                name: "reg-cn-detail",
+                description: "Detail for one reg_cn acceptance/review row. id is the encrypted id from reg-cn-search items (not the raw 受理号).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Encrypted record id from search results" },
+                    },
+                    required: ["id"],
+                },
+            },
+        ],
+    };
+});
+function encodeId(id) {
+    return encodeURIComponent(id).replace(/!/g, "%21");
+}
+function asQuery(query) {
+    return { ...(query ?? {}) };
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "yaohai-catalog": {
+                const validated = YaohaiCatalogSchema.parse(args ?? {});
+                const body = {};
+                if (validated.category)
+                    body.category = validated.category;
+                if (validated.q)
+                    body.q = validated.q;
+                const content = await yaohaiPost("/g/mcp/yaohai/catalog", body);
+                return ok(content);
+            }
+            case "yaohai-search": {
+                const validated = YaohaiSearchSchema.parse(args);
+                const content = await yaohaiPost("/g/mcp/yaohai/search", {
+                    dbname: validated.dbname,
+                    query: asQuery(validated.query),
+                    limit: clampLimit(validated.limit, YAOHAI_LIMIT_DEFAULT, YAOHAI_LIMIT_MAX),
+                    offset: clampOffset(validated.offset),
+                });
+                return ok(content);
+            }
+            case "yaohai-detail": {
+                const validated = YaohaiDetailSchema.parse(args);
+                const content = await yaohaiPost("/g/mcp/yaohai/detail", {
+                    dbname: validated.dbname,
+                    id: validated.id,
+                });
+                return ok(content);
+            }
+            case "yaohai-global-search": {
+                const validated = YaohaiGlobalSearchSchema.parse(args ?? {});
+                const query = asQuery(validated.query);
+                if (validated.q && (query.term === undefined || query.term === "")) {
+                    query.term = validated.q;
+                }
+                const content = await yaohaiPost("/g/mcp/yaohai/global-search", {
+                    query,
+                    limit: clampLimit(validated.limit, YAOHAI_LIMIT_DEFAULT, YAOHAI_LIMIT_MAX),
+                    offset: clampOffset(validated.offset),
+                });
+                return ok(content);
+            }
+            case "yaohai-smart-search": {
+                const validated = YaohaiSmartSearchSchema.parse(args);
+                const body = {
+                    q: validated.q,
+                    limit: clampLimit(validated.limit, YAOHAI_LIMIT_DEFAULT, YAOHAI_LIMIT_MAX),
+                };
+                if (validated.query) {
+                    body.query = validated.query;
+                }
+                const content = await yaohaiPost("/g/mcp/yaohai/smart-search", body);
+                return ok(content);
+            }
+            case "product-cn-fields": {
+                EmptyObjectSchema.parse(args ?? {});
+                return ok({
+                    common_search: [...PRODUCT_CN_COMMON_FIELDS],
+                    condition_search: PRODUCT_CN_FACET_FIELDS,
+                    view_types: [...PRODUCT_CN_VIEW_TYPES],
+                });
+            }
+            case "product-cn-search": {
+                const validated = ProductCnSearchSchema.parse(args ?? {});
+                const viewType = validated.view_type ?? "eslist";
+                const query = applyProductCnDefaults(asQuery(validated.query));
+                const limit = clampLimit(validated.limit, CN_LIMIT_DEFAULT, CN_LIMIT_MAX);
+                const offset = clampOffset(validated.offset);
+                const content = prefersMcpListApi()
+                    ? await mcpDbSearch({
+                        dbname: "product_cn",
+                        query,
+                        limit,
+                        offset,
+                        viewType,
+                    })
+                    : await listSearch({
+                        path: productCnSearchPath(viewType),
+                        query,
+                        limit,
+                        offset,
+                        viewType,
+                    });
+                return ok(content);
+            }
+            case "product-cn-facets": {
+                const validated = ProductCnFacetsSchema.parse(args);
+                const query = applyProductCnDefaults(asQuery(validated.query));
+                const content = await fetchFacets({
+                    prefix: PRODUCT_CN_FACET_PREFIX,
+                    query,
+                    fields: validated.facets,
+                    catalog: PRODUCT_CN_FACET_FIELDS,
+                });
+                return ok(content);
+            }
+            case "product-cn-detail": {
+                const validated = ProductCnDetailSchema.parse(args);
+                const content = prefersMcpListApi()
+                    ? await mcpDbDetail("product_cn", validated.id)
+                    : await fetchDetail(`${PRODUCT_CN_DETAIL_PATH}/${encodeId(validated.id)}`, validated.id);
+                return ok(content);
+            }
+            case "reg-cn-fields": {
+                EmptyObjectSchema.parse(args ?? {});
+                return ok({
+                    common_search: [...REG_CN_COMMON_FIELDS],
+                    condition_search: REG_CN_FACET_FIELDS,
+                    view_types: [...REG_CN_VIEW_TYPES],
+                });
+            }
+            case "reg-cn-search": {
+                const validated = RegCnSearchSchema.parse(args ?? {});
+                const viewType = validated.view_type ?? "eslist";
+                const query = applyRegCnDefaults(asQuery(validated.query));
+                const limit = clampLimit(validated.limit, CN_LIMIT_DEFAULT, CN_LIMIT_MAX);
+                const offset = clampOffset(validated.offset);
+                const content = prefersMcpListApi()
+                    ? await mcpDbSearch({
+                        dbname: "reg_cn",
+                        query,
+                        limit,
+                        offset,
+                        viewType,
+                    })
+                    : await listSearch({
+                        path: regCnSearchPath(viewType),
+                        query,
+                        limit,
+                        offset,
+                        viewType,
+                    });
+                return ok(content);
+            }
+            case "reg-cn-facets": {
+                const validated = RegCnFacetsSchema.parse(args);
+                const query = applyRegCnDefaults(asQuery(validated.query));
+                const content = await fetchFacets({
+                    prefix: REG_CN_FACET_PREFIX,
+                    query,
+                    fields: validated.facets,
+                    catalog: REG_CN_FACET_FIELDS,
+                });
+                return ok(content);
+            }
+            case "reg-cn-detail": {
+                const validated = RegCnDetailSchema.parse(args);
+                const content = prefersMcpListApi()
+                    ? await mcpDbDetail("reg_cn", validated.id)
+                    : await fetchDetail(`${REG_CN_DETAIL_PATH}/${encodeId(validated.id)}`, validated.id);
+                return ok(content);
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        };
+    }
+});
+function ok(content) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(content) }],
+        isError: false,
+    };
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/normalize.js

@@ -0,0 +1,137 @@
+/** Flatten DrugSea UI cell objects `{ text, title, url }` into plain values. */
+function isPlainObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+export function normalizeValue(v) {
+    if (v === null || v === undefined) {
+        return v;
+    }
+    if (typeof v === "boolean" || typeof v === "number") {
+        return v;
+    }
+    if (typeof v === "string") {
+        const trimmed = v.trim();
+        if (trimmed && (trimmed[0] === "[" || trimmed[0] === "{")) {
+            try {
+                return normalizeValue(JSON.parse(trimmed));
+            }
+            catch {
+                // keep original string
+            }
+        }
+        return v;
+    }
+    if (isPlainObject(v)) {
+        if ("text" in v && !("0" in v)) {
+            return normalizeValue(v.text);
+        }
+        const out = {};
+        for (const [k, val] of Object.entries(v)) {
+            out[k] = normalizeValue(val);
+        }
+        return out;
+    }
+    if (Array.isArray(v)) {
+        const texts = [];
+        for (const part of v) {
+            const t = isPlainObject(part) && "text" in part
+                ? normalizeValue(part.text)
+                : normalizeValue(part);
+            if (t === null || t === undefined || t === "") {
+                continue;
+            }
+            texts.push(String(t));
+        }
+        if (texts.length === 0) {
+            return "";
+        }
+        return texts.length === 1 ? texts[0] : texts.join("; ");
+    }
+    return String(v);
+}
+export function flattenRecord(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record)) {
+        if (k === "detail") {
+            continue;
+        }
+        out[k] = normalizeValue(v);
+    }
+    return out;
+}
+export function normalizeRecord(record) {
+    if (Array.isArray(record)) {
+        return record.map((row) => isPlainObject(row) ? flattenRecord(row) : row);
+    }
+    if (!isPlainObject(record)) {
+        return record;
+    }
+    const keys = Object.keys(record);
+    if (keys.length > 0 &&
+        keys.every((k, i) => k === String(i))) {
+        return keys.map((k) => {
+            const row = record[k];
+            return isPlainObject(row) ? flattenRecord(row) : row;
+        });
+    }
+    return flattenRecord(record);
+}
+function parseMaybeDict(item) {
+    try {
+        const parsed = JSON.parse(item);
+        if (isPlainObject(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // try python-ish single quotes
+    }
+    try {
+        const parsed = JSON.parse(item.replace(/'/g, '"'));
+        if (isPlainObject(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function parseFacetList(raw, field) {
+    let items = [];
+    if (Array.isArray(raw)) {
+        items = raw;
+    }
+    else if (typeof raw === "string") {
+        items = raw.split(";").map((p) => p.trim()).filter(Boolean);
+    }
+    else {
+        return [];
+    }
+    const out = [];
+    for (const item of items) {
+        let row = null;
+        if (isPlainObject(item)) {
+            row = item;
+        }
+        else if (typeof item === "string") {
+            row = parseMaybeDict(item);
+        }
+        if (!row) {
+            continue;
+        }
+        let value = row[field] ?? row.value ?? "";
+        if (isPlainObject(value)) {
+            value = value.title ?? value.value ?? value;
+        }
+        let count = row.ct ?? row.count ?? 0;
+        const n = typeof count === "number" ? count : Number.parseInt(String(count), 10);
+        out.push({
+            value,
+            count: Number.isFinite(n) ? n : 0,
+            raw: row,
+        });
+    }
+    out.sort((a, b) => b.count - a.count || String(a.value).localeCompare(String(b.value)));
+    return out.map(({ value, count }) => ({ value, count }));
+}

package/dist/types.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export const QueryValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+export const QueryObjectSchema = z.record(QueryValueSchema);
+export const YaohaiCatalogSchema = z.object({
+    category: z.string().optional(),
+    q: z.string().optional(),
+});
+export const YaohaiSearchSchema = z.object({
+    dbname: z.string().min(1),
+    query: QueryObjectSchema.optional(),
+    limit: z.coerce.number().int().optional(),
+    offset: z.coerce.number().int().optional(),
+});
+export const YaohaiDetailSchema = z.object({
+    dbname: z.string().min(1),
+    id: z.string().min(1),
+});
+export const YaohaiGlobalSearchSchema = z.object({
+    q: z.string().optional(),
+    query: QueryObjectSchema.optional(),
+    limit: z.coerce.number().int().optional(),
+    offset: z.coerce.number().int().optional(),
+});
+export const YaohaiSmartSearchSchema = z.object({
+    q: z.string().min(1),
+    query: QueryObjectSchema.optional(),
+    limit: z.coerce.number().int().optional(),
+});
+export const ProductViewTypeSchema = z.enum([
+    "eslist",
+    "list_by_drug_name",
+    "list_by_manufacture",
+]);
+export const RegViewTypeSchema = z.enum([
+    "eslist",
+    "list_by_drug_name",
+    "list_by_enterprise",
+]);
+export const ProductCnSearchSchema = z.object({
+    query: QueryObjectSchema.optional(),
+    limit: z.coerce.number().int().optional(),
+    offset: z.coerce.number().int().optional(),
+    view_type: ProductViewTypeSchema.optional(),
+});
+export const ProductCnFacetsSchema = z.object({
+    query: QueryObjectSchema.optional(),
+    facets: z.array(z.string().min(1)).min(1),
+});
+export const ProductCnDetailSchema = z.object({
+    id: z.string().min(1),
+});
+export const RegCnSearchSchema = z.object({
+    query: QueryObjectSchema.optional(),
+    limit: z.coerce.number().int().optional(),
+    offset: z.coerce.number().int().optional(),
+    view_type: RegViewTypeSchema.optional(),
+});
+export const RegCnFacetsSchema = z.object({
+    query: QueryObjectSchema.optional(),
+    facets: z.array(z.string().min(1)).min(1),
+});
+export const RegCnDetailSchema = z.object({
+    id: z.string().min(1),
+});
+export const EmptyObjectSchema = z.object({}).passthrough();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@kinginsun/mcp-drugsea",
+  "version": "0.1.0",
+  "description": "MCP server for DrugSea / Yaohai pharmaceutical databases: cross-db search, China marketed products (product_cn), and CDE registration review (reg_cn).",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-drugsea": "dist/index.js"
+  },
+  "homepage": "https://github.com/kinginsun/mcp-drugsea",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kinginsun/mcp-drugsea.git"
+  },
+  "license": "MIT",
+  "author": "kinginsun@CUHK",
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cli",
+    "drugsea",
+    "yaohai",
+    "nmpa",
+    "cde",
+    "pharmaceutical"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "shx": "^0.3.4",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}