@ythalorossy/openfda 1.0.3 → 1.0.5

package/build/OpenFDAClient.js

@@ -0,0 +1,174 @@
+const DEFAULT_CONFIG = {
+    maxRetries: 3,
+    retryDelay: 1000, // 1 second
+    timeout: 30000, // 30 seconds
+};
+// Helper function to determine if error is retryable
+function isRetryableError(error) {
+    // Network errors, timeouts, and 5xx server errors are retryable
+    if (error.name === "TypeError" && error.message.includes("fetch"))
+        return true;
+    if (error.name === "AbortError")
+        return true;
+    if (error.status >= 500 && error.status <= 599)
+        return true;
+    if (error.status === 429)
+        return true; // Rate limit
+    return false;
+}
+// Sleep utility for retry delays
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Enhanced OpenFDA request function
+async function makeOpenFDARequest(url, config = {}) {
+    const { maxRetries, retryDelay, timeout } = { ...DEFAULT_CONFIG, ...config };
+    const headers = {
+        "User-Agent": "@ythalorossy/openfda",
+        Accept: "application/json",
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            // Create abort controller for timeout handling
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            console.log(`Making OpenFDA request (attempt ${attempt + 1}/${maxRetries + 1}): ${url}`);
+            const response = await fetch(url, {
+                headers,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Handle HTTP errors with OpenFDA-specific context
+            if (!response.ok) {
+                const errorText = await response
+                    .text()
+                    .catch(() => "Unable to read error response");
+                const httpError = {
+                    type: "http",
+                    message: `HTTP ${response.status}: ${response.statusText}`,
+                    status: response.status,
+                    details: errorText,
+                };
+                console.error(`OpenFDA HTTP Error (${response.status}):`, {
+                    url,
+                    status: response.status,
+                    statusText: response.statusText,
+                    errorText: errorText.substring(0, 200), // Truncate long error messages
+                });
+                // OpenFDA-specific status code handling
+                switch (response.status) {
+                    case 400:
+                        httpError.message = `Bad Request: Invalid search query or parameters`;
+                        break;
+                    case 401:
+                        httpError.message = `Unauthorized: Invalid or missing API key`;
+                        break;
+                    case 403:
+                        httpError.message = `Forbidden: API key may be invalid or quota exceeded`;
+                        break;
+                    case 404:
+                        httpError.message = `Not Found: No results found for the specified query`;
+                        break;
+                    case 429:
+                        httpError.message = `Rate Limited: Too many requests. Retrying...`;
+                        break;
+                    case 500:
+                        httpError.message = `Server Error: OpenFDA service is experiencing issues`;
+                        break;
+                    default:
+                        httpError.message = `HTTP Error ${response.status}: ${response.statusText}`;
+                }
+                lastError = httpError;
+                // Don't retry client errors (4xx) except rate limiting
+                if (response.status >= 400 &&
+                    response.status < 500 &&
+                    response.status !== 429) {
+                    break;
+                }
+                // Retry server errors and rate limits
+                if (attempt < maxRetries &&
+                    isRetryableError({ status: response.status })) {
+                    const delay = retryDelay * Math.pow(2, attempt); // Exponential backoff
+                    console.log(`Retrying in ${delay}ms...`);
+                    await sleep(delay);
+                    continue;
+                }
+                break;
+            }
+            // Parse JSON response
+            let parsedData;
+            try {
+                parsedData = await response.json();
+            }
+            catch (parseError) {
+                const parsingError = {
+                    type: "parsing",
+                    message: `Failed to parse JSON response: ${parseError instanceof Error
+                        ? parseError.message
+                        : "Unknown parsing error"}`,
+                    details: parseError,
+                };
+                console.error("OpenFDA JSON Parsing Error:", {
+                    url,
+                    parseError: parseError instanceof Error ? parseError.message : parseError,
+                });
+                lastError = parsingError;
+                break; // Don't retry parsing errors
+            }
+            // Check for empty response
+            if (!parsedData) {
+                const emptyError = {
+                    type: "empty_response",
+                    message: "Received empty response from OpenFDA API",
+                };
+                lastError = emptyError;
+                break;
+            }
+            console.log(`OpenFDA request successful on attempt ${attempt + 1}`);
+            return { data: parsedData, error: null };
+        }
+        catch (error) {
+            // Handle network errors, timeouts, and other fetch errors
+            let networkError;
+            if (error.name === "AbortError") {
+                networkError = {
+                    type: "timeout",
+                    message: `Request timeout after ${timeout}ms`,
+                    details: error,
+                };
+            }
+            else if (error instanceof TypeError &&
+                error.message.includes("fetch")) {
+                networkError = {
+                    type: "network",
+                    message: `Network error: Unable to connect to OpenFDA API`,
+                    details: error.message,
+                };
+            }
+            else {
+                networkError = {
+                    type: "unknown",
+                    message: `Unexpected error: ${error.message || "Unknown error occurred"}`,
+                    details: error,
+                };
+            }
+            console.error(`OpenFDA Request Error (attempt ${attempt + 1}):`, {
+                url,
+                error: error.message,
+                type: error.name,
+            });
+            lastError = networkError;
+            // Retry network errors and timeouts
+            if (attempt < maxRetries && isRetryableError(error)) {
+                const delay = retryDelay * Math.pow(2, attempt); // Exponential backoff
+                console.log(`Network error, retrying in ${delay}ms...`);
+                await sleep(delay);
+                continue;
+            }
+            break;
+        }
+    }
+    return { data: null, error: lastError };
+}
+export { makeOpenFDARequest };

package/build/index.js

@@ -1,9 +1,8 @@
-#!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import z from "zod";
 import { OpenFDABuilder } from "./OpenFDABuilder.js";
-const USER_AGENT = "openfda-mcp/1.0";
+import { makeOpenFDARequest } from "./OpenFDAClient.js";
 const server = new McpServer({
     name: "openfda",
     version: "1.0.0",
@@ -13,29 +12,53 @@ const server = new McpServer({
         tools: {},
     },
 });
-// Helper function for making OpenFDA API requests
-async function makeOpenFDARequest(url) {
-    const headers = {
-        "User-Agent": USER_AGENT,
-        Accept: "application/json",
-    };
-    try {
-        const response = await fetch(url, { headers });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+// Helper function to normalize and validate NDC format
+function normalizeNDC(ndc) {
+    // Remove spaces and convert to uppercase
+    const cleanNDC = ndc.trim().toUpperCase();
+    // Check for different NDC formats:
+    // 1. XXXXX-XXXX (product NDC)
+    // 2. XXXXX-XXXX-XX (package NDC) 
+    // 3. XXXXXXXXXXX (11-digit without dashes)
+    // 4. XXXXXXXXX (9-digit without dashes - product only)
+    let productNDC;
+    let packageNDC = null;
+    if (cleanNDC.includes('-')) {
+        const parts = cleanNDC.split('-');
+        if (parts.length === 2) {
+            // Format: XXXXX-XXXX (product NDC)
+            productNDC = cleanNDC;
+            packageNDC = null;
+        }
+        else if (parts.length === 3) {
+            // Format: XXXXX-XXXX-XX (package NDC)
+            productNDC = `${parts[0]}-${parts[1]}`;
+            packageNDC = cleanNDC;
+        }
+        else {
+            return { productNDC: cleanNDC, packageNDC: null, isValid: false };
         }
-        return (await response.json());
     }
-    catch (error) {
-        console.error("Error making NWS request:", error);
-        return null;
+    else {
+        // No dashes - need to format based on length
+        if (cleanNDC.length === 11) {
+            // 11-digit package NDC: XXXXXYYYYZZ -> XXXXX-YYYY-ZZ
+            productNDC = `${cleanNDC.substring(0, 5)}-${cleanNDC.substring(5, 9)}`;
+            packageNDC = `${cleanNDC.substring(0, 5)}-${cleanNDC.substring(5, 9)}-${cleanNDC.substring(9, 11)}`;
+        }
+        else if (cleanNDC.length === 9) {
+            // 9-digit product NDC: XXXXXXXXX -> XXXXX-XXXX
+            productNDC = `${cleanNDC.substring(0, 5)}-${cleanNDC.substring(5, 9)}`;
+            packageNDC = null;
+        }
+        else {
+            return { productNDC: cleanNDC, packageNDC: null, isValid: false };
+        }
     }
+    // Basic validation
+    const isValid = /^\d{5}-\d{4}$/.test(productNDC);
+    return { productNDC, packageNDC, isValid };
 }
-// Tool: get-drug-by-name
-// Description: Retrieves drug information from the OpenFDA API by brand name.
-// Input: drugName (string) - The brand name of the drug to search for.
-// Output: Returns key drug information fields such as brand name, generic name, manufacturer, NDC, product type, route, substance name, indications and usage, warnings, and other safety information.
-// Usage: Use this tool to look up detailed drug label data for a given brand name.
 server.tool("get-drug-by-name", "Get drug by name. Use this tool to get the drug information by name. The drug name should be the brand name. It returns the brand name, generic name, manufacturer name, product NDC, product type, route, substance name, indications and usage, warnings, do not use, ask doctor, ask doctor or pharmacist, stop use, pregnancy or breast feeding.", {
     drugName: z.string().describe("Drug name"),
 }, async ({ drugName }) => {
@@ -44,18 +67,42 @@ server.tool("get-drug-by-name", "Get drug by name. Use this tool to get the drug
         .search(`openfda.brand_name:"${drugName}"`)
         .limit(1)
         .build();
-    const drugData = await makeOpenFDARequest(url);
-    if (!drugData) {
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        let errorMessage = `Failed to retrieve drug data for "${drugName}": ${error.message}`;
+        // Provide helpful suggestions based on error type
+        switch (error.type) {
+            case 'http':
+                if (error.status === 404) {
+                    errorMessage += `\n\nSuggestions:\n- Verify the exact brand name spelling\n- Try searching for the generic name instead\n- Check if the drug is FDA-approved`;
+                }
+                else if (error.status === 401 || error.status === 403) {
+                    errorMessage += `\n\nPlease check the API key configuration.`;
+                }
+                break;
+            case 'network':
+                errorMessage += `\n\nPlease check your internet connection and try again.`;
+                break;
+            case 'timeout':
+                errorMessage += `\n\nThe request took too long. Please try again.`;
+                break;
+        }
         return {
-            content: [
-                {
+            content: [{
                     type: "text",
-                    text: `Failed to retrieve drug data for ${drugName}`,
-                },
-            ],
+                    text: errorMessage,
+                }],
         };
     }
-    const drug = drugData.results.at(0);
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No drug information found for "${drugName}". Please verify the brand name spelling or try searching for the generic name.`,
+                }],
+        };
+    }
+    const drug = drugData.results[0];
     const drugInfo = {
         brand_name: drug?.openfda.brand_name,
         generic_name: drug?.openfda.generic_name,
@@ -73,18 +120,323 @@ server.tool("get-drug-by-name", "Get drug by name. Use this tool to get the drug
         pregnancy_or_breast_feeding: drug?.pregnancy_or_breast_feeding,
     };
     return {
-        content: [
-            {
+        content: [{
+                type: "text",
+                text: `Drug information retrieved successfully:\n\n${JSON.stringify(drugInfo, null, 2)}`,
+            }],
+    };
+});
+server.tool("get-drug-by-generic-name", "Get drug information by generic (active ingredient) name. Useful when you know the generic name but not the brand name. Returns all brand versions of the generic drug.", {
+    genericName: z.string().describe("Generic drug name (active ingredient)"),
+    limit: z.number().optional().default(5).describe("Maximum number of results to return")
+}, async ({ genericName, limit }) => {
+    const url = new OpenFDABuilder()
+        .context("label")
+        .search(`openfda.generic_name:"${genericName}"`)
+        .limit(limit)
+        .build();
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve drug data for generic name "${genericName}": ${error.message}`,
+                }],
+        };
+    }
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No drug information found for generic name "${genericName}".`,
+                }],
+        };
+    }
+    const drugs = drugData.results.map(drug => ({
+        brand_name: drug?.openfda.brand_name?.[0] || 'Unknown',
+        generic_name: drug?.openfda.generic_name?.[0] || 'Unknown',
+        manufacturer_name: drug?.openfda.manufacturer_name?.[0] || 'Unknown',
+        product_type: drug?.openfda.product_type?.[0] || 'Unknown',
+        route: drug?.openfda.route || [],
+    }));
+    return {
+        content: [{
+                type: "text",
+                text: `Found ${drugs.length} drug(s) with generic name "${genericName}":\n\n${JSON.stringify(drugs, null, 2)}`,
+            }],
+    };
+});
+server.tool("get-drug-adverse-events", "Get adverse event reports for a drug. This provides safety information about reported side effects and reactions. Use brand name or generic name.", {
+    drugName: z.string().describe("Drug name (brand or generic)"),
+    limit: z.number().optional().default(10).describe("Maximum number of events to return"),
+    seriousness: z.enum(["serious", "non-serious", "all"]).optional().default("all").describe("Filter by event seriousness")
+}, async ({ drugName, limit, seriousness }) => {
+    let searchQuery = `patient.drug.medicinalproduct:"${drugName}"`;
+    if (seriousness !== "all") {
+        const serious = seriousness === "serious" ? "1" : "2";
+        searchQuery += `+AND+serious:${serious}`;
+    }
+    const url = new OpenFDABuilder()
+        .context("event")
+        .search(searchQuery)
+        .limit(limit)
+        .build();
+    const { data: eventData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve adverse events for "${drugName}": ${error.message}`,
+                }],
+        };
+    }
+    if (!eventData || !eventData.results || eventData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No adverse events found for "${drugName}".`,
+                }],
+        };
+    }
+    const events = eventData.results.map((event) => ({
+        report_id: event.safetyreportid,
+        serious: event.serious === "1" ? "Yes" : "No",
+        patient_age: event.patient?.patientonsetage || "Unknown",
+        patient_sex: event.patient?.patientsex === "1" ? "Male" : event.patient?.patientsex === "2" ? "Female" : "Unknown",
+        reactions: event.patient?.reaction?.map((r) => r.reactionmeddrapt).slice(0, 3) || [],
+        outcomes: event.patient?.reaction?.map((r) => r.reactionoutcome).slice(0, 3) || [],
+        report_date: event.receiptdate || "Unknown"
+    }));
+    return {
+        content: [{
+                type: "text",
+                text: `Found ${events.length} adverse event report(s) for "${drugName}":\n\n${JSON.stringify(events, null, 2)}`,
+            }],
+    };
+});
+server.tool("get-drugs-by-manufacturer", "Get all drugs manufactured by a specific company. Useful for finding alternatives or checking manufacturer portfolios.", {
+    manufacturerName: z.string().describe("Manufacturer/company name"),
+    limit: z.number().optional().default(20).describe("Maximum number of drugs to return")
+}, async ({ manufacturerName, limit }) => {
+    const url = new OpenFDABuilder()
+        .context("label")
+        .search(`openfda.manufacturer_name:"${manufacturerName}"`)
+        .limit(limit)
+        .build();
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve drugs for manufacturer "${manufacturerName}": ${error.message}`,
+                }],
+        };
+    }
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No drugs found for manufacturer "${manufacturerName}".`,
+                }],
+        };
+    }
+    const drugs = drugData.results.map(drug => ({
+        brand_name: drug?.openfda.brand_name?.[0] || 'Unknown',
+        generic_name: drug?.openfda.generic_name?.[0] || 'Unknown',
+        product_type: drug?.openfda.product_type?.[0] || 'Unknown',
+        route: drug?.openfda.route || [],
+        ndc: drug?.openfda.product_ndc?.[0] || 'Unknown'
+    }));
+    return {
+        content: [{
+                type: "text",
+                text: `Found ${drugs.length} drug(s) from manufacturer "${manufacturerName}":\n\n${JSON.stringify(drugs, null, 2)}`,
+            }],
+    };
+});
+server.tool("get-drug-safety-info", "Get comprehensive safety information for a drug including warnings, contraindications, drug interactions, and precautions. Use brand name.", {
+    drugName: z.string().describe("Drug brand name")
+}, async ({ drugName }) => {
+    const url = new OpenFDABuilder()
+        .context("label")
+        .search(`openfda.brand_name:"${drugName}"`)
+        .limit(1)
+        .build();
+    console.log(`Calling: ${url}`);
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve safety information for "${drugName}": ${error.message}`,
+                }],
+        };
+    }
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No safety information found for "${drugName}".`,
+                }],
+        };
+    }
+    const drug = drugData.results[0];
+    const safetyInfo = {
+        drug_name: drug?.openfda.brand_name?.[0] || drugName,
+        generic_name: drug?.openfda.generic_name?.[0] || 'Unknown',
+        warnings: drug?.warnings || [],
+        contraindications: drug?.contraindications || [],
+        drug_interactions: drug?.drug_interactions || [],
+        precautions: drug?.precautions || [],
+        adverse_reactions: drug?.adverse_reactions || [],
+        overdosage: drug?.overdosage || [],
+        do_not_use: drug?.do_not_use || [],
+        ask_doctor: drug?.ask_doctor || [],
+        stop_use: drug?.stop_use || [],
+        pregnancy_or_breast_feeding: drug?.pregnancy_or_breast_feeding || []
+    };
+    return {
+        content: [{
+                type: "text",
+                text: `Safety information for "${drugName}":\n\n${JSON.stringify(safetyInfo, null, 2)}`,
+            }],
+    };
+});
+server.tool("get-drug-by-ndc", "Get drug information by National Drug Code (NDC). Accepts both product NDC (XXXXX-XXXX) and package NDC (XXXXX-XXXX-XX) formats. Also accepts NDC codes without dashes.", {
+    ndcCode: z.string().describe("National Drug Code (NDC) - accepts formats: XXXXX-XXXX, XXXXX-XXXX-XX, or without dashes")
+}, async ({ ndcCode }) => {
+    const { productNDC, packageNDC, isValid } = normalizeNDC(ndcCode);
+    if (!isValid) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Invalid NDC format: "${ndcCode}"\n\n✅ Accepted formats:\n• Product NDC: 12345-1234\n• Package NDC: 12345-1234-01\n• Without dashes: 123451234 or 12345123401`,
+                }],
+        };
+    }
+    console.log(`Searching for NDC: input="${ndcCode}", productNDC="${productNDC}", packageNDC="${packageNDC}"`);
+    // Try searching by product NDC first (most flexible)
+    let searchQuery = `openfda.product_ndc:"${productNDC}"`;
+    // If a specific package was requested, also search package NDC
+    if (packageNDC) {
+        searchQuery += `+OR+openfda.package_ndc:"${packageNDC}"`;
+    }
+    const url = new OpenFDABuilder()
+        .context("label")
+        .search(searchQuery)
+        .limit(10) // Get multiple results since product NDC might have multiple packages
+        .build();
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve drug data for NDC "${ndcCode}": ${error.message}`,
+                }],
+        };
+    }
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No drug found with NDC "${ndcCode}" (product: ${productNDC}).\n\n💡 Tips:\n• Verify the NDC format\n• Try without the package suffix (e.g., use 12345-1234 instead of 12345-1234-01)\n• Check if this is an FDA-approved product`,
+                }],
+        };
+    }
+    // Process results and group by product
+    const results = drugData.results.map(drug => {
+        const matchingProductNDCs = drug.openfda.product_ndc?.filter(ndc => ndc === productNDC) || [];
+        const matchingPackageNDCs = drug.openfda.package_ndc?.filter(ndc => packageNDC ? ndc === packageNDC : ndc.startsWith(productNDC)) || [];
+        return {
+            // Basic drug information
+            brand_name: drug.openfda.brand_name || [],
+            generic_name: drug.openfda.generic_name || [],
+            manufacturer_name: drug.openfda.manufacturer_name || [],
+            product_type: drug.openfda.product_type || [],
+            route: drug.openfda.route || [],
+            substance_name: drug.openfda.substance_name || [],
+            // NDC information
+            matching_product_ndc: matchingProductNDCs,
+            matching_package_ndc: matchingPackageNDCs,
+            all_product_ndc: drug.openfda.product_ndc || [],
+            all_package_ndc: drug.openfda.package_ndc || [],
+            // Additional product details
+            dosage_and_administration: drug.dosage_and_administration || [],
+            package_label_principal_display_panel: drug.package_label_principal_display_panel || [],
+            active_ingredient: drug.active_ingredient || [],
+            purpose: drug.purpose || []
+        };
+    });
+    // Summary information
+    const totalPackages = results.reduce((sum, result) => sum + result.matching_package_ndc.length, 0);
+    const searchSummary = packageNDC
+        ? `Searched for specific package NDC: ${packageNDC}`
+        : `Searched for product NDC: ${productNDC} (all packages)`;
+    return {
+        content: [{
+                type: "text",
+                text: `✅ Found ${results.length} drug(s) with ${totalPackages} package(s) for NDC "${ndcCode}"\n\n${searchSummary}\n\n${JSON.stringify(results, null, 2)}`,
+            }],
+    };
+});
+// Alternative: Simple product-only NDC search tool
+server.tool("get-drug-by-product-ndc", "Get drug information by product NDC only (XXXXX-XXXX format). This ignores package variations and finds all packages for a product.", {
+    productNDC: z.string().describe("Product NDC in format XXXXX-XXXX")
+}, async ({ productNDC }) => {
+    // Validate product NDC format
+    if (!/^\d{5}-\d{4}$/.test(productNDC.trim())) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Invalid product NDC format: "${productNDC}"\n\n✅ Required format: XXXXX-XXXX (e.g., 12345-1234)`,
+                }],
+        };
+    }
+    const url = new OpenFDABuilder()
+        .context("label")
+        .search(`openfda.product_ndc:"${productNDC.trim()}"`)
+        .limit(1)
+        .build();
+    const { data: drugData, error } = await makeOpenFDARequest(url);
+    if (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to retrieve drug data for product NDC "${productNDC}": ${error.message}`,
+                }],
+        };
+    }
+    if (!drugData || !drugData.results || drugData.results.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No drug found with product NDC "${productNDC}".`,
+                }],
+        };
+    }
+    const drug = drugData.results[0];
+    // Get all packages for this product
+    const allPackagesForProduct = drug.openfda.package_ndc?.filter(ndc => ndc.startsWith(productNDC.trim())) || [];
+    const drugInfo = {
+        product_ndc: productNDC,
+        available_packages: allPackagesForProduct,
+        brand_name: drug.openfda.brand_name || [],
+        generic_name: drug.openfda.generic_name || [],
+        manufacturer_name: drug.openfda.manufacturer_name || [],
+        product_type: drug.openfda.product_type || [],
+        route: drug.openfda.route || [],
+        substance_name: drug.openfda.substance_name || [],
+        active_ingredient: drug.active_ingredient || [],
+        purpose: drug.purpose || [],
+        dosage_and_administration: drug.dosage_and_administration || []
+    };
+    return {
+        content: [{
                 type: "text",
-                text: `drug: ${JSON.stringify(drugInfo)}`,
-            },
-        ],
+                text: `✅ Product NDC "${productNDC}" found with ${allPackagesForProduct.length} package variation(s):\n\n${JSON.stringify(drugInfo, null, 2)}`,
+            }],
     };
 });
-// The above code registers a tool named "get-drug-by-name" with the MCP server.
-// This tool allows users to retrieve detailed drug label information from the OpenFDA API
-// by providing a brand name. It constructs the appropriate API request, fetches the data,
-// and returns key drug information fields in a structured text response.
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ythalorossy/openfda",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "OpenFDA Model Context Protocol",
   "repository": {
     "type": "git",
@@ -29,7 +29,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.15.1",
-    "@ythalorossy/openfda": "^1.0.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {