@sequoiaport/codes 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/mcp.js

@@ -0,0 +1,581 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/mcp.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod4 = require("zod");
+
+// src/errors.ts
+var CodesApiError = class extends Error {
+  constructor(status, message, action) {
+    super(message);
+    this.status = status;
+    this.action = action;
+    this.name = "CodesApiError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      status: this.status,
+      message: this.message,
+      action: this.action
+    };
+  }
+};
+
+// src/engines.ts
+var import_zod = require("zod");
+var SnomedSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var SnomedIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var SnomedCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = SnomedSearchCodeInputSchema.parse(input);
+    return this.request(
+      "snomed/searchCode",
+      validated
+    );
+  }
+  async identifyCode(input) {
+    const validated = SnomedIdentifyCodeInputSchema.parse(input);
+    return this.request("snomed/identifyCode", {
+      code: validated.code
+    });
+  }
+};
+var Icd10SearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional(),
+  billingOnly: import_zod.z.boolean().optional()
+});
+var Icd10IdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var Icd10Category = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = Icd10SearchCodeInputSchema.parse(input);
+    return this.request("icd10/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = Icd10IdentifyCodeInputSchema.parse(input);
+    return this.request("icd10/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getChapters() {
+    return this.request("icd10/getChapters", {});
+  }
+};
+var CptSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var CptIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptGetCostInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptLinkIcd10InputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = CptSearchCodeInputSchema.parse(input);
+    return this.request("cpt/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = CptIdentifyCodeInputSchema.parse(input);
+    return this.request("cpt/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getCost(input) {
+    const validated = CptGetCostInputSchema.parse(input);
+    return this.request("cpt/getCost", {
+      code: validated.code
+    });
+  }
+  async linkIcd10(input) {
+    const validated = CptLinkIcd10InputSchema.parse(input);
+    return this.request("cpt/linkIcd10", {
+      code: validated.code
+    });
+  }
+};
+var HcpcsSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var HcpcsIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var HcpcsGetCostInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var HcpcsCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = HcpcsSearchCodeInputSchema.parse(input);
+    return this.request("hcpcs/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = HcpcsIdentifyCodeInputSchema.parse(input);
+    return this.request("hcpcs/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getCost(input) {
+    const validated = HcpcsGetCostInputSchema.parse(input);
+    return this.request("hcpcs/getCost", {
+      code: validated.code
+    });
+  }
+};
+var LoincSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var LoincIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var LoincGetPanelMembersInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var LoincCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = LoincSearchCodeInputSchema.parse(input);
+    return this.request(
+      "loinc/searchCode",
+      validated
+    );
+  }
+  async identifyCode(input) {
+    const validated = LoincIdentifyCodeInputSchema.parse(input);
+    return this.request("loinc/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getPanelMembers(input) {
+    const validated = LoincGetPanelMembersInputSchema.parse(input);
+    return this.request(
+      "loinc/getPanelMembers",
+      { code: validated.code }
+    );
+  }
+};
+var RxnormSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var RxnormIdentifyCodeInputSchema = import_zod.z.object({
+  type: import_zod.z.enum(["ndc", "rxcui"]),
+  code: import_zod.z.string().min(1)
+});
+var RxnormGetIngredientsInputSchema = import_zod.z.object({
+  rxcui: import_zod.z.string().min(1)
+});
+var RxnormCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = RxnormSearchCodeInputSchema.parse(input);
+    return this.request("rxnorm/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = RxnormIdentifyCodeInputSchema.parse(input);
+    return this.request(
+      "rxnorm/identifyCode",
+      { type: validated.type, code: validated.code }
+    );
+  }
+  async getIngredients(input) {
+    const validated = RxnormGetIngredientsInputSchema.parse(input);
+    return this.request(
+      "rxnorm/getIngredients",
+      validated
+    );
+  }
+};
+var LcdSearchGuidelinesInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var LcdIdentifyGuidelineInputSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1)
+});
+var LcdCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchGuidelines(input) {
+    const validated = LcdSearchGuidelinesInputSchema.parse(input);
+    return this.request(
+      "lcd/searchGuidelines",
+      validated
+    );
+  }
+  async identifyGuideline(input) {
+    const validated = LcdIdentifyGuidelineInputSchema.parse(input);
+    return this.request("lcd/identifyGuideline", {
+      id: validated.id
+    });
+  }
+};
+var NcdSearchGuidelinesInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var NcdIdentifyGuidelineInputSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  section: import_zod.z.string().optional()
+}).refine((data) => data.id || data.section, {
+  message: "Either id or section must be provided"
+});
+var NcdCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchGuidelines(input) {
+    const validated = NcdSearchGuidelinesInputSchema.parse(input);
+    return this.request(
+      "ncd/searchGuidelines",
+      validated
+    );
+  }
+  async identifyGuideline(input) {
+    const validated = NcdIdentifyGuidelineInputSchema.parse(input);
+    return this.request("ncd/identifyGuideline", {
+      id: validated.id,
+      section: validated.section
+    });
+  }
+};
+
+// src/schemas/clinical.ts
+var import_zod2 = require("zod");
+var DiagnosisToProceduresInputSchema = import_zod2.z.object({
+  snomed_id: import_zod2.z.string().optional(),
+  icd10_code: import_zod2.z.string().optional(),
+  query: import_zod2.z.string().optional()
+});
+var CoverageCheckInputSchema = import_zod2.z.object({
+  cpt_code: import_zod2.z.string().min(1),
+  icd10_code: import_zod2.z.string().optional()
+});
+var DiagnosisToProceduresOutputSchema = import_zod2.z.object({
+  snomed_id: import_zod2.z.string().optional(),
+  icd10_code: import_zod2.z.string().optional(),
+  icd10_mappings: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional(),
+  procedures: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional()
+});
+var CoverageCheckOutputSchema = import_zod2.z.object({
+  cpt_code: import_zod2.z.string(),
+  icd10_code: import_zod2.z.string().optional(),
+  lcd: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  has_guidelines: import_zod2.z.boolean(),
+  diagnosis_covered: import_zod2.z.boolean().optional()
+});
+var GetCategoriesOutputSchema = import_zod2.z.object({
+  snomed_semantic_tags: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  icd10_chapters: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional(),
+  cpt_categories: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional()
+});
+
+// src/schemas/system.ts
+var import_zod3 = require("zod");
+var GetResultInputSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string().min(1)
+});
+var GetResultOutputSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string(),
+  status: import_zod3.z.enum(["pending", "running", "completed", "failed"]),
+  query: import_zod3.z.string().optional(),
+  result: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  error: import_zod3.z.string().optional()
+});
+var EngineStatusSchema = import_zod3.z.record(import_zod3.z.enum(["ok", "error", "unknown"]));
+var HealthOutputSchema = import_zod3.z.object({
+  status: import_zod3.z.enum(["ok", "degraded"]),
+  version: import_zod3.z.string().optional(),
+  environment: import_zod3.z.string().optional(),
+  engines: EngineStatusSchema.optional()
+});
+
+// src/client.ts
+var ClinicalCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Check LCD coverage for a CPT code + optional ICD-10 pair */
+  async checkCoverage(input) {
+    const validated = CoverageCheckInputSchema.parse(input);
+    return this.request(
+      "clinical/checkCoverage",
+      validated
+    );
+  }
+  /** Map a diagnosis (SNOMED or ICD-10) to relevant procedures */
+  async getProceduresForDiagnosis(input) {
+    const validated = DiagnosisToProceduresInputSchema.parse(input);
+    return this.request(
+      "clinical/getProceduresForDiagnosis",
+      validated
+    );
+  }
+  /** Get metadata/categories from all engines (semantic tags, chapters, etc.) */
+  async getMetadata() {
+    return this.request("clinical/getMetadata", {});
+  }
+};
+var SystemCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Get async request result by ID */
+  async getResult(input) {
+    const validated = GetResultInputSchema.parse(input);
+    return this.request("system/getResult", validated);
+  }
+  /** Health check all engines */
+  async health() {
+    return this.request("system/health", {});
+  }
+};
+var DEFAULT_BASE_URL = "https://api.sequoiacodes.com";
+var DEFAULT_VERSION = "v1";
+var SequoiaCodesClient = class {
+  apiKey;
+  baseUrl;
+  version;
+  // ==========================================================================
+  // Orchestrator Categories
+  // ==========================================================================
+  /** Clinical orchestrator: coverage check, diagnosis-to-procedures, metadata */
+  clinical;
+  /** System actions: get async result, health check */
+  system;
+  // ==========================================================================
+  // Coding System Categories
+  // ==========================================================================
+  /** SNOMED CT coding system */
+  snomed;
+  /** ICD-10 diagnosis codes */
+  icd10;
+  /** CPT procedure codes */
+  cpt;
+  /** HCPCS procedure codes */
+  hcpcs;
+  /** LOINC laboratory test codes */
+  loinc;
+  /** RxNorm drug/medication codes */
+  rxnorm;
+  // ==========================================================================
+  // Guideline Categories
+  // ==========================================================================
+  /** LCD (Local Coverage Determination) guidelines */
+  lcd;
+  /** NCD (National Coverage Determination) guidelines */
+  ncd;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.version = config.version ?? DEFAULT_VERSION;
+    const boundRequest = this.request.bind(this);
+    this.clinical = new ClinicalCategory(boundRequest);
+    this.system = new SystemCategory(boundRequest);
+    this.snomed = new SnomedCategory(boundRequest);
+    this.icd10 = new Icd10Category(boundRequest);
+    this.cpt = new CptCategory(boundRequest);
+    this.hcpcs = new HcpcsCategory(boundRequest);
+    this.loinc = new LoincCategory(boundRequest);
+    this.rxnorm = new RxnormCategory(boundRequest);
+    this.lcd = new LcdCategory(boundRequest);
+    this.ncd = new NcdCategory(boundRequest);
+  }
+  /**
+   * Make an HTTP request to the Codes API Gateway.
+   */
+  async request(path, params, method = "GET") {
+    const url = new URL(`${this.baseUrl}/${this.version}/${path}`);
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const options = {
+      method,
+      headers
+    };
+    if (method === "GET" && params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            url.searchParams.set(key, JSON.stringify(value));
+          } else if (typeof value === "object") {
+            url.searchParams.set(key, JSON.stringify(value));
+          } else {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+    } else if (method === "POST" && params) {
+      options.body = JSON.stringify(params);
+    }
+    const response = await fetch(url.toString(), options);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new CodesApiError(
+        response.status,
+        data.error || "Unknown error",
+        path
+      );
+    }
+    return data.data;
+  }
+};
+
+// src/mcp.ts
+var CODE_SYSTEMS = ["icd10", "cpt", "hcpcs", "snomed", "rxnorm", "loinc"];
+var GUIDELINE_SYSTEMS = ["lcd", "ncd"];
+var apiKey = process.env.SEQUOIA_CODES_API_KEY;
+if (!apiKey) {
+  console.error("SEQUOIA_CODES_API_KEY environment variable is required");
+  process.exit(1);
+}
+var client = new SequoiaCodesClient({ apiKey });
+var server = new import_mcp.McpServer({
+  name: "sequoia-codes",
+  version: "0.1.0"
+});
+server.tool(
+  "searchCode",
+  "Search medical codes by description across ICD-10, CPT, HCPCS, SNOMED, RxNorm, or LOINC systems.",
+  {
+    system: import_zod4.z.enum(CODE_SYSTEMS).describe("The coding system to search"),
+    query: import_zod4.z.string().min(1).describe("Search text (e.g. 'diabetes', 'knee replacement')"),
+    limit: import_zod4.z.number().int().min(1).max(200).optional().describe("Max results (1-200)"),
+    billingOnly: import_zod4.z.boolean().optional().describe("ICD-10 only: filter to billable codes")
+  },
+  async ({ system, query, limit, billingOnly }) => {
+    const params = { query };
+    if (limit !== void 0) params.limit = limit;
+    if (system === "icd10" && billingOnly !== void 0) params.billingOnly = billingOnly;
+    const result = await client[system].searchCode(params);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "identifyCode",
+  "Look up a specific medical code, get cost data, ICD-10 links, panel members, ingredients, or chapters.",
+  {
+    system: import_zod4.z.enum(CODE_SYSTEMS).describe("The coding system"),
+    code: import_zod4.z.string().default("").describe("The code to look up (not needed for getChapters)"),
+    type: import_zod4.z.enum(["ndc", "rxcui"]).optional().describe("RxNorm only: lookup type"),
+    action: import_zod4.z.enum(["lookup", "getCost", "linkIcd10", "getPanelMembers", "getIngredients", "getChapters"]).default("lookup").describe(
+      "lookup (default), getCost (CPT/HCPCS), linkIcd10 (CPT), getPanelMembers (LOINC), getIngredients (RxNorm), getChapters (ICD-10)"
+    )
+  },
+  async ({ system, code, type, action }) => {
+    let result;
+    switch (action) {
+      case "getCost":
+        if (system !== "cpt" && system !== "hcpcs") {
+          return { content: [{ type: "text", text: "getCost is only available for cpt and hcpcs systems" }] };
+        }
+        result = await client[system].getCost({ code });
+        break;
+      case "linkIcd10":
+        if (system !== "cpt") {
+          return { content: [{ type: "text", text: "linkIcd10 is only available for the cpt system" }] };
+        }
+        result = await client.cpt.linkIcd10({ code });
+        break;
+      case "getPanelMembers":
+        if (system !== "loinc") {
+          return { content: [{ type: "text", text: "getPanelMembers is only available for the loinc system" }] };
+        }
+        result = await client.loinc.getPanelMembers({ code });
+        break;
+      case "getIngredients":
+        if (system !== "rxnorm") {
+          return { content: [{ type: "text", text: "getIngredients is only available for the rxnorm system" }] };
+        }
+        result = await client.rxnorm.getIngredients({ rxcui: code });
+        break;
+      case "getChapters":
+        if (system !== "icd10") {
+          return { content: [{ type: "text", text: "getChapters is only available for the icd10 system" }] };
+        }
+        result = await client.icd10.getChapters();
+        break;
+      default: {
+        if (system === "rxnorm") {
+          result = await client.rxnorm.identifyCode({ type: type ?? "rxcui", code });
+        } else {
+          result = await client[system].identifyCode({ code });
+        }
+        break;
+      }
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "searchGuidelines",
+  "Search or look up Medicare coverage guidelines (LCD/NCD). Provide query to search, or id/section to look up a specific guideline.",
+  {
+    system: import_zod4.z.enum(GUIDELINE_SYSTEMS).describe("lcd (Local Coverage) or ncd (National Coverage)"),
+    query: import_zod4.z.string().optional().describe("Search text for guidelines"),
+    id: import_zod4.z.string().optional().describe("Guideline ID for direct lookup"),
+    section: import_zod4.z.string().optional().describe("NCD only: section number (e.g. '220.6')"),
+    limit: import_zod4.z.number().int().min(1).max(200).optional().describe("Max results (1-200)")
+  },
+  async ({ system, query, id, section, limit }) => {
+    let result;
+    if (query) {
+      const params = { query };
+      if (limit !== void 0) params.limit = limit;
+      result = await client[system].searchGuidelines(params);
+    } else if (id || section) {
+      if (system === "ncd") {
+        result = await client.ncd.identifyGuideline({ id, section });
+      } else {
+        if (!id) {
+          return { content: [{ type: "text", text: "LCD lookup requires an id" }] };
+        }
+        result = await client.lcd.identifyGuideline({ id });
+      }
+    } else {
+      return { content: [{ type: "text", text: "Provide either query (to search) or id/section (to look up a specific guideline)" }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("MCP server failed to start:", err);
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@sequoiaport/codes",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.2",
   "description": "Retrieve ICD-10, CPT, SNOMED, and more medical codes via the Sequoia Codes API.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "sequoia-codes-mcp": "./dist/mcp.js"
+  },
   "scripts": {
     "build": "tsup"
   },
@@ -26,12 +29,21 @@
     "api",
     "sdk"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Sequoia-Port/codes.git"
+  },
+  "homepage": "https://github.com/Sequoia-Port/codes",
+  "bugs": {
+    "url": "https://github.com/Sequoia-Port/codes/issues"
+  },
   "author": "wconvery",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "zod": "^3.23.0"
   },
   "devDependencies": {