@cyanheads/pubchem-mcp-server 1.0.1 → 1.0.2

package/dist/mcp-server/server.js

@@ -24,7 +24,7 @@ import { registerPubchemSearchCompoundsByStructureTool } from "./tools/searchCom
 import { registerPubchemSearchCompoundsBySimilarityTool } from "./tools/searchCompoundsBySimilarity/index.js";
 import { registerPubchemSearchCompoundsByFormulaTool } from "./tools/searchCompoundsByFormula/index.js";
 import { registerPubchemFetchSubstanceDetailsTool } from "./tools/fetchSubstanceDetails/index.js";
-import { registerPubchemFetchAssaySummaryTool } from "./tools/fetchAssaySummary/index.js";
+import { registerPubchemGetSummaryTool } from "./tools/getSummary/index.js";
 import { registerPubchemSearchAssaysByTargetTool } from "./tools/searchAssaysByTarget/index.js";
 import { registerPubchemFetchCompoundXrefsTool } from "./tools/fetchCompoundXrefs/index.js";
 import { startHttpTransport } from "./transports/httpTransport.js";
@@ -62,7 +62,7 @@ async function createMcpServerInstance() {
         await registerPubchemSearchCompoundsBySimilarityTool(server);
         await registerPubchemSearchCompoundsByFormulaTool(server);
         await registerPubchemFetchSubstanceDetailsTool(server);
-        await registerPubchemFetchAssaySummaryTool(server);
+        await registerPubchemGetSummaryTool(server);
         await registerPubchemSearchAssaysByTargetTool(server);
         await registerPubchemFetchCompoundXrefsTool(server);
         logger.info("Resources and tools registered successfully", context);

package/dist/mcp-server/tools/fetchCompoundProperties/logic.js

@@ -81,19 +81,29 @@ export async function pubchemFetchCompoundPropertiesLogic(params, context) {
         params,
     });
     const { cids, properties } = params;
-    const cidsString = cids.join(",");
     const propertiesString = properties.join(",");
-    const path = `/compound/cid/${cidsString}/property/${propertiesString}/JSON`;
-    const response = await pubChemApiClient.get(path, context);
-    logger.debug("Raw PubChem response for pubchem_fetch_compound_properties", {
-        ...context,
-        response,
+    const promises = cids.map(async (cid) => {
+        const path = `/compound/cid/${cid}/property/${propertiesString}/JSON`;
+        try {
+            const response = await pubChemApiClient.get(path, context);
+            return response?.PropertyTable?.Properties || [];
+        }
+        catch (error) {
+            logger.warning(`Failed to fetch properties for CID ${cid}`, {
+                ...context,
+                cid,
+                error,
+            });
+            return []; // Return empty array for this CID on failure
+        }
     });
-    if (!response || !response.PropertyTable?.Properties) {
-        throw new McpError(BaseErrorCode.NOT_FOUND, "Received an unexpected response format from PubChem API. Ensure CIDs are valid.", { ...context, cids, response });
+    const results = await Promise.all(promises);
+    const allProperties = results.flat();
+    if (allProperties.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "Could not fetch properties for any of the provided CIDs.", { ...context, cids });
     }
     const result = {
-        results: response.PropertyTable.Properties,
+        results: allProperties,
     };
     logger.info(`Successfully fetched properties for ${result.results.length} CIDs.`, context);
     return result;

package/dist/mcp-server/tools/fetchSubstanceDetails/registration.js

@@ -13,7 +13,7 @@ import { PubchemFetchSubstanceDetailsInputSchema, pubchemFetchSubstanceDetailsLo
  */
 export const registerPubchemFetchSubstanceDetailsTool = async (server) => {
     const toolName = "pubchem_fetch_substance_details";
-    const toolDescription = "Retrieves details for a given PubChem Substance ID (SID), including its synonyms, source, deposition/modification dates, and any associated standardized Compound IDs (CIDs).";
+    const toolDescription = "Retrieves a comprehensive record for a PubChem Substance ID (SID), including its source, deposition/modification dates, synonyms, associated Compound IDs (CIDs), and full cross-reference (xref) and compound data structures if available.";
     server.tool(toolName, toolDescription, PubchemFetchSubstanceDetailsInputSchema.shape, async (params, mcpContext) => {
         const handlerContext = requestContextService.createRequestContext({
             operation: "HandleToolRequest",

package/dist/mcp-server/tools/getSummary/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Barrel file for the `getSummary` tool, exporting its registration function.
+ * @module src/mcp-server/tools/getSummary/index
+ */
+export { registerPubchemGetSummaryTool } from "./registration.js";

package/dist/mcp-server/tools/getSummary/index.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Barrel file for the `getSummary` tool, exporting its registration function.
+ * @module src/mcp-server/tools/getSummary/index
+ */
+export { registerPubchemGetSummaryTool } from "./registration.js";

package/dist/mcp-server/tools/getSummary/logic.d.ts

@@ -0,0 +1,184 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the unified `pubchem_get_summary` tool.
+ * @module src/mcp-server/tools/getSummary/logic
+ */
+import { z } from "zod";
+import { type RequestContext } from "../../../utils/index.js";
+declare const AssaySummarySchema: z.ZodObject<{
+    aid: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    sourceName: z.ZodString;
+    numSids: z.ZodNumber;
+    numActive: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    aid: number;
+    sourceName: string;
+    numSids: number;
+    numActive: number;
+}, {
+    name: string;
+    description: string;
+    aid: number;
+    sourceName: string;
+    numSids: number;
+    numActive: number;
+}>;
+declare const GeneSummarySchema: z.ZodObject<{
+    geneId: z.ZodNumber;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    taxonomyId: z.ZodNumber;
+    taxonomy: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    synonyms: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    synonyms: string[];
+    geneId: number;
+    taxonomyId: number;
+    taxonomy: string;
+    description?: string | undefined;
+}, {
+    symbol: string;
+    name: string;
+    synonyms: string[];
+    geneId: number;
+    taxonomyId: number;
+    taxonomy: string;
+    description?: string | undefined;
+}>;
+declare const ProteinSummarySchema: z.ZodObject<{
+    proteinAccession: z.ZodString;
+    name: z.ZodString;
+    taxonomyId: z.ZodNumber;
+    taxonomy: z.ZodString;
+    synonyms: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    synonyms: string[];
+    taxonomyId: number;
+    taxonomy: string;
+    proteinAccession: string;
+}, {
+    name: string;
+    synonyms: string[];
+    taxonomyId: number;
+    taxonomy: string;
+    proteinAccession: string;
+}>;
+declare const PathwaySummarySchema: z.ZodObject<{
+    pathwayAccession: z.ZodString;
+    sourceName: z.ZodString;
+    sourceId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    taxonomyId: z.ZodNumber;
+    taxonomy: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    sourceId: string;
+    sourceName: string;
+    taxonomyId: number;
+    taxonomy: string;
+    pathwayAccession: string;
+    category: string;
+    description?: string | undefined;
+}, {
+    type: string;
+    name: string;
+    sourceId: string;
+    sourceName: string;
+    taxonomyId: number;
+    taxonomy: string;
+    pathwayAccession: string;
+    category: string;
+    description?: string | undefined;
+}>;
+declare const TaxonomySummarySchema: z.ZodObject<{
+    taxonomyId: z.ZodNumber;
+    scientificName: z.ZodString;
+    commonName: z.ZodOptional<z.ZodString>;
+    rank: z.ZodString;
+    rankedLineage: z.ZodArray<z.ZodObject<{
+        rank: z.ZodString;
+        name: z.ZodString;
+        taxId: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        rank: string;
+        taxId: number;
+    }, {
+        name: string;
+        rank: string;
+        taxId: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    taxonomyId: number;
+    scientificName: string;
+    rank: string;
+    rankedLineage: {
+        name: string;
+        rank: string;
+        taxId: number;
+    }[];
+    commonName?: string | undefined;
+}, {
+    taxonomyId: number;
+    scientificName: string;
+    rank: string;
+    rankedLineage: {
+        name: string;
+        rank: string;
+        taxId: number;
+    }[];
+    commonName?: string | undefined;
+}>;
+declare const CellSummarySchema: z.ZodObject<{
+    cellAccession: z.ZodString;
+    name: z.ZodString;
+    sex: z.ZodOptional<z.ZodString>;
+    category: z.ZodString;
+    sourceTissue: z.ZodString;
+    sourceOrganism: z.ZodString;
+    sourceTaxonomyId: z.ZodNumber;
+    synonyms: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    synonyms: string[];
+    category: string;
+    cellAccession: string;
+    sourceTissue: string;
+    sourceOrganism: string;
+    sourceTaxonomyId: number;
+    sex?: string | undefined;
+}, {
+    name: string;
+    synonyms: string[];
+    category: string;
+    cellAccession: string;
+    sourceTissue: string;
+    sourceOrganism: string;
+    sourceTaxonomyId: number;
+    sex?: string | undefined;
+}>;
+export declare const PubchemGetSummaryInputSchema: z.ZodObject<{
+    summaryType: z.ZodEnum<["assay", "gene", "protein", "pathway", "taxonomy", "cell"]>;
+    identifiers: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    identifiers: (string | number)[];
+    summaryType: "taxonomy" | "assay" | "gene" | "protein" | "pathway" | "cell";
+}, {
+    identifiers: (string | number)[];
+    summaryType: "taxonomy" | "assay" | "gene" | "protein" | "pathway" | "cell";
+}>;
+export type PubchemGetSummaryInput = z.infer<typeof PubchemGetSummaryInputSchema>;
+export type PubchemGetSummaryOutput = z.infer<typeof AssaySummarySchema>[] | z.infer<typeof GeneSummarySchema>[] | z.infer<typeof ProteinSummarySchema>[] | z.infer<typeof PathwaySummarySchema>[] | z.infer<typeof TaxonomySummarySchema>[] | z.infer<typeof CellSummarySchema>[];
+export declare function pubchemGetSummaryLogic(params: PubchemGetSummaryInput, context: RequestContext): Promise<PubchemGetSummaryOutput>;
+export {};

package/dist/mcp-server/tools/getSummary/logic.js

@@ -0,0 +1,230 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the unified `pubchem_get_summary` tool.
+ * @module src/mcp-server/tools/getSummary/logic
+ */
+import { z } from "zod";
+import { pubChemApiClient } from "../../../services/pubchem/pubchemApiClient.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { logger } from "../../../utils/index.js";
+// Define individual summary schemas
+const AssaySummarySchema = z.object({
+    aid: z.number().int(),
+    name: z.string(),
+    description: z.string(),
+    sourceName: z.string(),
+    numSids: z.number().int(),
+    numActive: z.number().int(),
+});
+const GeneSummarySchema = z.object({
+    geneId: z.number().int(),
+    symbol: z.string(),
+    name: z.string(),
+    taxonomyId: z.number().int(),
+    taxonomy: z.string(),
+    description: z.string().optional(),
+    synonyms: z.array(z.string()),
+});
+const ProteinSummarySchema = z.object({
+    proteinAccession: z.string(),
+    name: z.string(),
+    taxonomyId: z.number().int(),
+    taxonomy: z.string(),
+    synonyms: z.array(z.string()),
+});
+const PathwaySummarySchema = z.object({
+    pathwayAccession: z.string(),
+    sourceName: z.string(),
+    sourceId: z.string(),
+    name: z.string(),
+    type: z.string(),
+    category: z.string(),
+    description: z.string().optional(),
+    taxonomyId: z.number().int(),
+    taxonomy: z.string(),
+});
+const TaxonomySummarySchema = z.object({
+    taxonomyId: z.number().int(),
+    scientificName: z.string(),
+    commonName: z.string().optional(),
+    rank: z.string(),
+    rankedLineage: z.array(z.object({
+        rank: z.string(),
+        name: z.string(),
+        taxId: z.number().int(),
+    })),
+});
+const CellSummarySchema = z.object({
+    cellAccession: z.string(),
+    name: z.string(),
+    sex: z.string().optional(),
+    category: z.string(),
+    sourceTissue: z.string(),
+    sourceOrganism: z.string(),
+    sourceTaxonomyId: z.number().int(),
+    synonyms: z.array(z.string()),
+});
+// Input Schema
+export const PubchemGetSummaryInputSchema = z.object({
+    summaryType: z.enum(["assay", "gene", "protein", "pathway", "taxonomy", "cell"])
+        .describe("The type of PubChem entity for which to fetch a summary."),
+    identifiers: z.array(z.union([z.string(), z.number().int().positive()]))
+        .min(1)
+        .describe("An array of identifiers for the specified entity type. Examples: " +
+        "Assay (AID): [1000], " +
+        "Gene (GeneID): [1956], " +
+        "Protein (Accession): [\"P00533\"], " +
+        "Pathway (Accession with prefix): [\"Reactome:R-HSA-70171\"], " +
+        "Taxonomy (TaxID): [9606], " +
+        "Cell (Accession): [\"CVCL_0030\"]"),
+});
+// Logic
+async function fetchAssaySummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/assay/aid/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for assay ID ${id}`, { ...context, response });
+        return response?.AssaySummaries?.AssaySummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No assay summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        aid: s.AID,
+        name: s.Name,
+        description: Array.isArray(s.Description) ? s.Description.join("\\n") : s.Description,
+        sourceName: s.SourceName,
+        numSids: s.SIDCountAll,
+        numActive: s.CIDCountActive,
+    }));
+}
+async function fetchGeneSummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/gene/geneid/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for gene ID ${id}`, { ...context, response });
+        return response?.GeneSummaries?.GeneSummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No gene summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        geneId: s.GeneID,
+        symbol: s.Symbol,
+        name: s.Name,
+        taxonomyId: s.TaxonomyID,
+        taxonomy: s.Taxonomy,
+        description: s.Description,
+        synonyms: s.Synonym || [],
+    }));
+}
+async function fetchProteinSummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/protein/accession/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for protein accession ${id}`, { ...context, response });
+        return response?.ProteinSummaries?.ProteinSummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No protein summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        proteinAccession: s.ProteinAccession,
+        name: s.Name,
+        taxonomyId: s.TaxonomyID,
+        taxonomy: s.Taxonomy,
+        synonyms: s.Synonym || [],
+    }));
+}
+async function fetchPathwaySummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/pathway/pwacc/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for pathway accession ${id}`, { ...context, response });
+        return response?.PathwaySummaries?.PathwaySummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No pathway summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        pathwayAccession: s.PathwayAccession,
+        sourceName: s.SourceName,
+        sourceId: s.SourceID,
+        name: s.Name,
+        type: s.Type,
+        category: s.Category,
+        description: s.Description,
+        taxonomyId: s.TaxonomyID,
+        taxonomy: s.Taxonomy,
+    }));
+}
+async function fetchTaxonomySummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/taxonomy/taxid/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for taxonomy ID ${id}`, { ...context, response });
+        return response?.TaxonomySummaries?.TaxonomySummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No taxonomy summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        taxonomyId: s.TaxonomyID,
+        scientificName: s.ScientificName,
+        commonName: s.CommonName,
+        rank: s.Rank,
+        rankedLineage: s.RankedLineage || [],
+    }));
+}
+async function fetchCellSummary(identifiers, context) {
+    const promises = identifiers.map(async (id) => {
+        const path = `/cell/cellacc/${id}/summary/JSON`;
+        const response = await pubChemApiClient.get(path, context);
+        logger.debug(`Response for cell accession ${id}`, { ...context, response });
+        return response?.CellSummaries?.CellSummary || [];
+    });
+    const results = await Promise.all(promises);
+    const summaries = results.flat();
+    if (summaries.length === 0) {
+        throw new McpError(BaseErrorCode.NOT_FOUND, "No cell summaries found for the provided identifiers.", context);
+    }
+    return summaries.map((s) => ({
+        cellAccession: s.CellAccession,
+        name: s.Name,
+        sex: s.Sex,
+        category: s.Category,
+        sourceTissue: s.SourceTissue,
+        sourceOrganism: s.SourceOrganism,
+        sourceTaxonomyId: s.SourceTaxonomyID,
+        synonyms: s.Synonym || [],
+    }));
+}
+export async function pubchemGetSummaryLogic(params, context) {
+    logger.debug("Processing pubchem_get_summary logic...", { ...context, params });
+    const { summaryType, identifiers } = params;
+    switch (summaryType) {
+        case "assay":
+            return fetchAssaySummary(identifiers, context);
+        case "gene":
+            return fetchGeneSummary(identifiers, context);
+        case "protein":
+            return fetchProteinSummary(identifiers, context);
+        case "pathway":
+            return fetchPathwaySummary(identifiers, context);
+        case "taxonomy":
+            return fetchTaxonomySummary(identifiers, context);
+        case "cell":
+            return fetchCellSummary(identifiers, context);
+        default:
+            throw new McpError(BaseErrorCode.INVALID_INPUT, `Invalid summary type: ${summaryType}`, context);
+    }
+}

package/dist/mcp-server/tools/getSummary/registration.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_get_summary` tool with the MCP server.
+ * @module src/mcp-server/tools/getSummary/registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers the 'pubchem_get_summary' tool with the provided MCP server instance.
+ * This tool retrieves a summary for various PubChem data types.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export declare const registerPubchemGetSummaryTool: (server: McpServer) => Promise<void>;

package/dist/mcp-server/tools/getSummary/registration.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_get_summary` tool with the MCP server.
+ * @module src/mcp-server/tools/getSummary/registration
+ */
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { PubchemGetSummaryInputSchema, pubchemGetSummaryLogic, } from "./logic.js";
+/**
+ * Registers the 'pubchem_get_summary' tool with the provided MCP server instance.
+ * This tool retrieves a summary for various PubChem data types.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export const registerPubchemGetSummaryTool = async (server) => {
+    const toolName = "pubchem_get_summary";
+    const toolDescription = "Fetches a summary for a given PubChem entity type (assay, gene, protein, pathway, taxonomy, cell) and a list of identifiers.";
+    server.tool(toolName, toolDescription, PubchemGetSummaryInputSchema.shape, async (params, mcpContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            operation: "HandleToolRequest",
+            toolName,
+            mcpToolContext: mcpContext,
+            input: params,
+        });
+        try {
+            logger.info(`Initiating tool request for ${toolName} with type: ${params.summaryType}`, handlerContext);
+            const result = await pubchemGetSummaryLogic(params, handlerContext);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            const handledError = ErrorHandler.handleError(error, {
+                operation: "pubchemGetSummaryToolHandler",
+                context: handlerContext,
+                input: params,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: ErrorHandler.formatError(handledError),
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyanheads/pubchem-mcp-server",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A Model Context Protocol (MCP) server providing comprehensive LLM tools for the PubChem PUG REST API.",
   "main": "dist/index.js",
   "files": [

package/dist/mcp-server/tools/fetchAssaySummary/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * @fileoverview Barrel file for the `pubchem_fetch_assay_summary` tool.
- * This file serves as the public interface for the tool module,
- * primarily exporting the `registerPubchemFetchAssaySummaryTool` function.
- * @module src/mcp-server/tools/fetchAssaySummary/index
- */
-export { registerPubchemFetchAssaySummaryTool } from "./registration.js";

package/dist/mcp-server/tools/fetchAssaySummary/index.js

@@ -1,7 +0,0 @@
-/**
- * @fileoverview Barrel file for the `pubchem_fetch_assay_summary` tool.
- * This file serves as the public interface for the tool module,
- * primarily exporting the `registerPubchemFetchAssaySummaryTool` function.
- * @module src/mcp-server/tools/fetchAssaySummary/index
- */
-export { registerPubchemFetchAssaySummaryTool } from "./registration.js";

package/dist/mcp-server/tools/fetchAssaySummary/logic.d.ts

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Defines the core logic, schemas, and types for the `pubchem_fetch_assay_summary` tool.
- * @module src/mcp-server/tools/fetchAssaySummary/logic
- */
-import { z } from "zod";
-import { type RequestContext } from "../../../utils/index.js";
-export declare const PubchemFetchAssaySummaryInputSchema: z.ZodObject<{
-    aids: z.ZodArray<z.ZodNumber, "many">;
-}, "strip", z.ZodTypeAny, {
-    aids: number[];
-}, {
-    aids: number[];
-}>;
-export type PubchemFetchAssaySummaryInput = z.infer<typeof PubchemFetchAssaySummaryInputSchema>;
-export declare const AssaySummarySchema: z.ZodObject<{
-    aid: z.ZodNumber;
-    name: z.ZodString;
-    description: z.ZodString;
-    sourceName: z.ZodString;
-    numSids: z.ZodNumber;
-    numActive: z.ZodNumber;
-    targets: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        geneId: z.ZodOptional<z.ZodNumber>;
-        geneSymbol: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        geneId?: number | undefined;
-        geneSymbol?: string | undefined;
-    }, {
-        name: string;
-        geneId?: number | undefined;
-        geneSymbol?: string | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    aid: number;
-    sourceName: string;
-    numSids: number;
-    numActive: number;
-    targets: {
-        name: string;
-        geneId?: number | undefined;
-        geneSymbol?: string | undefined;
-    }[];
-}, {
-    name: string;
-    description: string;
-    aid: number;
-    sourceName: string;
-    numSids: number;
-    numActive: number;
-    targets: {
-        name: string;
-        geneId?: number | undefined;
-        geneSymbol?: string | undefined;
-    }[];
-}>;
-export type AssaySummary = z.infer<typeof AssaySummarySchema>;
-export type PubchemFetchAssaySummaryOutput = AssaySummary[];
-/**
- * Core logic for the `pubchem_fetch_assay_summary` tool. It retrieves a summary
- * for a specified list of PubChem BioAssay IDs (AIDs).
- *
- * @param {PubchemFetchAssaySummaryInput} params - The validated input parameters, containing the AIDs.
- * @param {RequestContext} context - The request context for logging, tracing, and error handling.
- * @returns {Promise<PubchemFetchAssaySummaryOutput>} A promise that resolves with an array of structured assay summaries.
- * @throws {McpError} Throws a structured error if the API request fails, any AID is not found, or the response is malformed.
- */
-export declare function pubchemFetchAssaySummaryLogic(params: PubchemFetchAssaySummaryInput, context: RequestContext): Promise<PubchemFetchAssaySummaryOutput>;

package/dist/mcp-server/tools/fetchAssaySummary/logic.js

@@ -1,96 +0,0 @@
-/**
- * @fileoverview Defines the core logic, schemas, and types for the `pubchem_fetch_assay_summary` tool.
- * @module src/mcp-server/tools/fetchAssaySummary/logic
- */
-import { z } from "zod";
-import { pubChemApiClient } from "../../../services/pubchem/pubchemApiClient.js";
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { logger } from "../../../utils/index.js";
-// 1. Define and export the Zod schema for input validation
-export const PubchemFetchAssaySummaryInputSchema = z.object({
-    aids: z
-        .array(z.number().int().positive())
-        .min(1, "At least one Assay ID (AID) must be provided.")
-        .max(5, "A maximum of 5 Assay IDs (AIDs) can be provided.")
-        .describe("An array of PubChem BioAssay IDs (AIDs). Must contain 1 to 5 positive integers."),
-});
-// 3. Define and export the Zod schema for a single assay summary object
-export const AssaySummarySchema = z.object({
-    aid: z.number().int().describe("The unique PubChem BioAssay ID (AID)."),
-    name: z.string().describe("The official name of the bioassay."),
-    description: z
-        .string()
-        .describe("A detailed description of the assay's purpose and methods."),
-    sourceName: z
-        .string()
-        .describe("The name of the institution or entity that provided the assay."),
-    numSids: z
-        .number()
-        .int()
-        .describe("The total number of substances (SIDs) tested in the assay."),
-    numActive: z
-        .number()
-        .int()
-        .describe("The number of substances found to be active in the assay."),
-    targets: z
-        .array(z.object({
-        name: z.string().describe("Name of the biological target."),
-        geneId: z
-            .number()
-            .int()
-            .optional()
-            .describe("NCBI Gene ID, if available."),
-        geneSymbol: z
-            .string()
-            .optional()
-            .describe("Official gene symbol, if available."),
-    }))
-        .describe("Biological targets of the assay. Note: This is often empty as the summary endpoint may not provide target details."),
-});
-/**
- * Core logic for the `pubchem_fetch_assay_summary` tool. It retrieves a summary
- * for a specified list of PubChem BioAssay IDs (AIDs).
- *
- * @param {PubchemFetchAssaySummaryInput} params - The validated input parameters, containing the AIDs.
- * @param {RequestContext} context - The request context for logging, tracing, and error handling.
- * @returns {Promise<PubchemFetchAssaySummaryOutput>} A promise that resolves with an array of structured assay summaries.
- * @throws {McpError} Throws a structured error if the API request fails, any AID is not found, or the response is malformed.
- */
-export async function pubchemFetchAssaySummaryLogic(params, context) {
-    logger.debug("Processing pubchem_fetch_assay_summary logic...", {
-        ...context,
-        params,
-    });
-    const { aids } = params;
-    const path = `/assay/aid/${aids.join(",")}/summary/JSON`;
-    const response = await pubChemApiClient.get(path, context);
-    logger.debug("Raw PubChem response for pubchem_fetch_assay_summary", {
-        ...context,
-        aids,
-        response,
-    });
-    const summaries = response?.AssaySummaries?.AssaySummary;
-    if (!summaries || summaries.length === 0) {
-        throw new McpError(BaseErrorCode.NOT_FOUND, `No assay summaries found for AIDs [${aids.join(", ")}], or the response from PubChem was malformed.`, { ...context, aids, response });
-    }
-    const results = summaries.map((summary) => {
-        // Safely extract description, handling both string and array formats.
-        let description = "No description provided.";
-        if (summary.Description) {
-            description = Array.isArray(summary.Description)
-                ? summary.Description.join("\n")
-                : summary.Description;
-        }
-        return {
-            aid: summary.AID ?? 0,
-            name: summary.Name ?? "N/A",
-            description,
-            sourceName: summary.SourceName ?? "N/A",
-            numSids: summary.SIDCountAll ?? 0,
-            numActive: summary.CIDCountActive ?? 0,
-            targets: [], // The summary endpoint does not provide target details. This is expected.
-        };
-    });
-    logger.info(`Successfully fetched ${results.length} summaries for AIDs [${aids.join(", ")}].`, context);
-    return results;
-}

package/dist/mcp-server/tools/fetchAssaySummary/registration.d.ts

@@ -1,12 +0,0 @@
-/**
- * @fileoverview Handles the registration of the `pubchem_fetch_assay_summary` tool with the MCP server.
- * @module src/mcp-server/tools/fetchAssaySummary/registration
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-/**
- * Registers the 'pubchem_fetch_assay_summary' tool with the provided MCP server instance.
- * This tool retrieves a detailed summary for a given PubChem BioAssay ID (AID).
- *
- * @param {McpServer} server - The MCP server instance to register the tool with.
- */
-export declare const registerPubchemFetchAssaySummaryTool: (server: McpServer) => Promise<void>;

package/dist/mcp-server/tools/fetchAssaySummary/registration.js

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Handles the registration of the `pubchem_fetch_assay_summary` tool with the MCP server.
- * @module src/mcp-server/tools/fetchAssaySummary/registration
- */
-import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
-import { PubchemFetchAssaySummaryInputSchema, pubchemFetchAssaySummaryLogic, } from "./logic.js";
-/**
- * Registers the 'pubchem_fetch_assay_summary' tool with the provided MCP server instance.
- * This tool retrieves a detailed summary for a given PubChem BioAssay ID (AID).
- *
- * @param {McpServer} server - The MCP server instance to register the tool with.
- */
-export const registerPubchemFetchAssaySummaryTool = async (server) => {
-    const toolName = "pubchem_fetch_assay_summary";
-    const toolDescription = "Fetches detailed summaries for a list of up to 5 PubChem BioAssay IDs (AIDs), including their names, descriptions, sources, and statistics. This is useful for obtaining metadata about multiple biological assays in a single request.";
-    server.tool(toolName, toolDescription, PubchemFetchAssaySummaryInputSchema.shape, async (params, mcpContext) => {
-        const handlerContext = requestContextService.createRequestContext({
-            operation: "HandleToolRequest",
-            toolName,
-            mcpToolContext: mcpContext,
-            input: params,
-        });
-        try {
-            logger.info(`Initiating tool request for ${toolName} with AIDs: ${params.aids.join(", ")}`, handlerContext);
-            const result = await pubchemFetchAssaySummaryLogic(params, handlerContext);
-            // Custom stringify to make large arrays of numbers more compact
-            const placeholderPrefix = "##JSON_STRINGIFY_PLACEHOLDER##";
-            let placeholderIndex = 0;
-            const placeholders = [];
-            const replacer = (key, value) => {
-                if (Array.isArray(value) &&
-                    value.every((item) => typeof item === "number")) {
-                    const placeholder = `${placeholderPrefix}${placeholderIndex++}`;
-                    placeholders.push(JSON.stringify(value));
-                    return placeholder;
-                }
-                return value;
-            };
-            let text = JSON.stringify(result, replacer, 2);
-            for (let i = 0; i < placeholders.length; i++) {
-                text = text.replace(`"${placeholderPrefix}${i}"`, placeholders[i]);
-            }
-            return {
-                content: [{ type: "text", text }],
-                isError: false,
-            };
-        }
-        catch (error) {
-            const handledError = ErrorHandler.handleError(error, {
-                operation: "pubchemFetchAssaySummaryToolHandler",
-                context: handlerContext,
-                input: params,
-            });
-            // No need to log here, handleError already does it.
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: ErrorHandler.formatError(handledError),
-                        }),
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-};