@cyanheads/pubchem-mcp-server 1.0.1

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

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_get_compound_image` tool.
+ * This tool fetches the raw image data for a given compound.
+ * @module src/mcp-server/tools/getCompoundImage/logic
+ */
+import { z } from "zod";
+import { type RequestContext } from "../../../utils/index.js";
+export declare const PubchemGetCompoundImageInputSchema: z.ZodObject<{
+    cid: z.ZodNumber;
+    size: z.ZodDefault<z.ZodOptional<z.ZodEnum<["small", "large"]>>>;
+}, "strip", z.ZodTypeAny, {
+    cid: number;
+    size: "small" | "large";
+}, {
+    cid: number;
+    size?: "small" | "large" | undefined;
+}>;
+export type PubchemGetCompoundImageInput = z.infer<typeof PubchemGetCompoundImageInputSchema>;
+export declare const PubchemGetCompoundImageOutputSchema: z.ZodObject<{
+    cid: z.ZodNumber;
+    blob: z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>;
+    mimeType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mimeType: string;
+    blob: Buffer<ArrayBufferLike>;
+    cid: number;
+}, {
+    mimeType: string;
+    blob: Buffer<ArrayBufferLike>;
+    cid: number;
+}>;
+export type PubchemGetCompoundImageOutput = z.infer<typeof PubchemGetCompoundImageOutputSchema>;
+/**
+ * Core logic for the `pubchem_get_compound_image` tool. It constructs the image URL,
+ * fetches the image data, and returns it as a blob.
+ *
+ * @param {PubchemGetCompoundImageInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemGetCompoundImageOutput>} A promise that resolves with the image blob and metadata.
+ * @throws {McpError} Throws a structured error if the image fetch fails or the CID is invalid.
+ */
+export declare function pubchemGetCompoundImageLogic(params: PubchemGetCompoundImageInput, context: RequestContext): Promise<PubchemGetCompoundImageOutput>;

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

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_get_compound_image` tool.
+ * This tool fetches the raw image data for a given compound.
+ * @module src/mcp-server/tools/getCompoundImage/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 PubchemGetCompoundImageInputSchema = z.object({
+    cid: z
+        .number()
+        .int()
+        .positive()
+        .describe("The PubChem Compound ID (CID) for which to fetch the image. Must be a positive integer."),
+    size: z
+        .enum(["small", "large"])
+        .optional()
+        .default("large")
+        .describe("Specifies the desired image size: 'small' (100x100) or 'large' (300x300). Defaults to 'large'."),
+});
+// 3. Define and export the Zod schema for the tool's output
+export const PubchemGetCompoundImageOutputSchema = z.object({
+    cid: z
+        .number()
+        .int()
+        .describe("The CID of the compound depicted in the image."),
+    blob: z.instanceof(Buffer).describe("The raw image data as a Buffer object."),
+    mimeType: z
+        .string()
+        .describe("The MIME type of the image (e.g., 'image/png')."),
+});
+const PUBCHEM_IMAGE_BASE_URL = "https://pubchem.ncbi.nlm.nih.gov/rest/pug";
+/**
+ * Core logic for the `pubchem_get_compound_image` tool. It constructs the image URL,
+ * fetches the image data, and returns it as a blob.
+ *
+ * @param {PubchemGetCompoundImageInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemGetCompoundImageOutput>} A promise that resolves with the image blob and metadata.
+ * @throws {McpError} Throws a structured error if the image fetch fails or the CID is invalid.
+ */
+export async function pubchemGetCompoundImageLogic(params, context) {
+    logger.debug("Processing pubchem_get_compound_image logic...", {
+        ...context,
+        params,
+    });
+    const { cid, size } = params;
+    const imageUrl = `${PUBCHEM_IMAGE_BASE_URL}/compound/cid/${cid}/PNG?record_type=2d&image_size=${size}`;
+    try {
+        const arrayBuffer = await pubChemApiClient.getBlob(imageUrl, context);
+        const result = {
+            cid,
+            blob: Buffer.from(arrayBuffer),
+            mimeType: "image/png",
+        };
+        logger.info(`Successfully fetched image for CID ${cid}.`, context);
+        return result;
+    }
+    catch (error) {
+        logger.error(`Failed to fetch image for CID ${cid} from ${imageUrl}`, {
+            ...context,
+            error,
+        });
+        throw new McpError(BaseErrorCode.EXTERNAL_SERVICE_ERROR, `Failed to fetch image for CID ${cid}. The compound may not exist or there was a network issue.`, { ...context, cid, imageUrl });
+    }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_get_compound_image` tool.
+ * @module src/mcp-server/tools/getCompoundImage/registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers the 'pubchem_get_compound_image' tool with the MCP server.
+ * This tool fetches a 2D image of a compound's structure and returns it as a binary blob.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export declare const registerPubchemGetCompoundImageTool: (server: McpServer) => Promise<void>;

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

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_get_compound_image` tool.
+ * @module src/mcp-server/tools/getCompoundImage/registration
+ */
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { PubchemGetCompoundImageInputSchema, pubchemGetCompoundImageLogic, } from "./logic.js";
+/**
+ * Registers the 'pubchem_get_compound_image' tool with the MCP server.
+ * This tool fetches a 2D image of a compound's structure and returns it as a binary blob.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export const registerPubchemGetCompoundImageTool = async (server) => {
+    const toolName = "pubchem_get_compound_image";
+    const toolDescription = "Fetches a 2D image of a compound's structure for a given PubChem CID and returns the raw image data as a binary blob. Ideal for displaying chemical structures directly.";
+    server.tool(toolName, toolDescription, PubchemGetCompoundImageInputSchema.shape, async (params, mcpContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            operation: "HandleToolRequest",
+            toolName,
+            mcpToolContext: mcpContext,
+            input: params,
+        });
+        try {
+            logger.info(`Initiating tool request for ${toolName} for CID: ${params.cid}`, handlerContext);
+            const result = await pubchemGetCompoundImageLogic(params, handlerContext);
+            return {
+                content: [
+                    {
+                        type: "image",
+                        data: result.blob.toString("base64"),
+                        mimeType: result.mimeType,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            const handledError = ErrorHandler.handleError(error, {
+                operation: "pubchemGetCompoundImageToolHandler",
+                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,
+            };
+        }
+    });
+};

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

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

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_search_assays_by_target` tool.
+ * @module src/mcp-server/tools/searchAssaysByTarget/logic
+ */
+import { z } from "zod";
+import { type RequestContext } from "../../../utils/index.js";
+export declare const PubchemSearchAssaysByTargetInputSchema: z.ZodObject<{
+    targetType: z.ZodEnum<["genesymbol", "proteinname"]>;
+    targetQuery: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    targetType: "genesymbol" | "proteinname";
+    targetQuery: string;
+}, {
+    targetType: "genesymbol" | "proteinname";
+    targetQuery: string;
+}>;
+export type PubchemSearchAssaysByTargetInput = z.infer<typeof PubchemSearchAssaysByTargetInputSchema>;
+export declare const PubchemSearchAssaysByTargetOutputSchema: z.ZodObject<{
+    aids: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    aids: number[];
+}, {
+    aids: number[];
+}>;
+export type PubchemSearchAssaysByTargetOutput = z.infer<typeof PubchemSearchAssaysByTargetOutputSchema>;
+/**
+ * Core logic for the `pubchem_search_assays_by_target` tool. It finds BioAssay IDs (AIDs)
+ * associated with a specific biological target.
+ *
+ * @param {PubchemSearchAssaysByTargetInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemSearchAssaysByTargetOutput>} A promise that resolves with a list of AIDs.
+ * @throws {McpError} Throws a structured error if the API request fails or returns a fault.
+ */
+export declare function pubchemSearchAssaysByTargetLogic(params: PubchemSearchAssaysByTargetInput, context: RequestContext): Promise<PubchemSearchAssaysByTargetOutput>;

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

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_search_assays_by_target` tool.
+ * @module src/mcp-server/tools/searchAssaysByTarget/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 PubchemSearchAssaysByTargetInputSchema = z.object({
+    targetType: z
+        .enum(["genesymbol", "proteinname"])
+        .describe("The type of biological target to search by."),
+    targetQuery: z
+        .string()
+        .min(1, "Target query cannot be empty.")
+        .describe("The identifier for the target, such as 'EGFR' for a gene symbol or 'Epidermal growth factor receptor' for a protein name."),
+});
+// 3. Define and export the Zod schema for the tool's output
+export const PubchemSearchAssaysByTargetOutputSchema = z.object({
+    aids: z
+        .array(z.number().int())
+        .describe("A list of PubChem BioAssay IDs (AIDs) associated with the specified target."),
+});
+/**
+ * Core logic for the `pubchem_search_assays_by_target` tool. It finds BioAssay IDs (AIDs)
+ * associated with a specific biological target.
+ *
+ * @param {PubchemSearchAssaysByTargetInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemSearchAssaysByTargetOutput>} A promise that resolves with a list of AIDs.
+ * @throws {McpError} Throws a structured error if the API request fails or returns a fault.
+ */
+export async function pubchemSearchAssaysByTargetLogic(params, context) {
+    logger.debug("Processing pubchem_search_assays_by_target logic...", {
+        ...context,
+        params,
+    });
+    const { targetType, targetQuery } = params;
+    const path = `/assay/target/${targetType}/${encodeURIComponent(targetQuery)}/aids/JSON`;
+    const response = await pubChemApiClient.get(path, context);
+    logger.debug("Raw PubChem response for pubchem_search_assays_by_target", {
+        ...context,
+        response,
+    });
+    if (response?.Fault) {
+        logger.error("PubChem API returned a fault for target search.", {
+            ...context,
+            fault: response.Fault,
+        });
+        throw new McpError(BaseErrorCode.EXTERNAL_SERVICE_ERROR, `PubChem API Fault: ${response.Fault.Message}`, { ...context, details: response.Fault.Details });
+    }
+    if (!response ||
+        !response.IdentifierList?.AID ||
+        !Array.isArray(response.IdentifierList.AID)) {
+        logger.warning("No AIDs found for the target search, or the response format was unexpected. Returning empty list.", { ...context, targetQuery, response });
+        return { aids: [] };
+    }
+    const result = {
+        aids: response.IdentifierList.AID,
+    };
+    logger.info(`Found ${result.aids.length} AIDs for target query '${targetQuery}'.`, context);
+    return result;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_search_assays_by_target` tool.
+ * @module src/mcp-server/tools/searchAssaysByTarget/registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers the 'pubchem_search_assays_by_target' tool with the MCP server.
+ * This tool finds PubChem BioAssay IDs (AIDs) associated with a specific biological target.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export declare const registerPubchemSearchAssaysByTargetTool: (server: McpServer) => Promise<void>;

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

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_search_assays_by_target` tool.
+ * @module src/mcp-server/tools/searchAssaysByTarget/registration
+ */
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { PubchemSearchAssaysByTargetInputSchema, pubchemSearchAssaysByTargetLogic, } from "./logic.js";
+/**
+ * Registers the 'pubchem_search_assays_by_target' tool with the MCP server.
+ * This tool finds PubChem BioAssay IDs (AIDs) associated with a specific biological target.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export const registerPubchemSearchAssaysByTargetTool = async (server) => {
+    const toolName = "pubchem_search_assays_by_target";
+    const toolDescription = "Finds PubChem BioAssay IDs (AIDs) associated with a specific biological target, such as a gene symbol (e.g., 'EGFR') or a full protein name.";
+    server.tool(toolName, toolDescription, PubchemSearchAssaysByTargetInputSchema.shape, async (params, mcpContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            operation: "HandleToolRequest",
+            toolName,
+            mcpToolContext: mcpContext,
+            input: params,
+        });
+        try {
+            logger.info(`Initiating tool request for ${toolName} for target: '${params.targetQuery}'`, handlerContext);
+            const result = await pubchemSearchAssaysByTargetLogic(params, handlerContext);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            const handledError = ErrorHandler.handleError(error, {
+                operation: "pubchemSearchAssaysByTargetToolHandler",
+                context: handlerContext,
+                input: params,
+            });
+            const mcpError = handledError instanceof McpError
+                ? handledError
+                : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred while searching for assays by target.", { originalErrorName: handledError.name });
+            logger.error(`Error in ${toolName} handler`, {
+                ...handlerContext,
+                error: mcpError,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: {
+                                code: mcpError.code,
+                                message: mcpError.message,
+                                details: mcpError.details,
+                            },
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+};

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

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

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_search_compound_by_identifier` tool.
+ * @module src/mcp-server/tools/searchCompoundByIdentifier/logic
+ */
+import { z } from "zod";
+import { type RequestContext } from "../../../utils/index.js";
+export declare const PubchemSearchCompoundByIdentifierInputSchema: z.ZodObject<{
+    identifierType: z.ZodEnum<["name", "smiles", "inchikey"]>;
+    identifiers: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    identifierType: "name" | "smiles" | "inchikey";
+    identifiers: string[];
+}, {
+    identifierType: "name" | "smiles" | "inchikey";
+    identifiers: string[];
+}>;
+export type PubchemSearchCompoundByIdentifierInput = z.infer<typeof PubchemSearchCompoundByIdentifierInputSchema>;
+export declare const PubchemSearchCompoundByIdentifierOutputSchema: z.ZodObject<{
+    results: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    results: Record<string, number[]>;
+}, {
+    results: Record<string, number[]>;
+}>;
+export type PubchemSearchCompoundByIdentifierOutput = z.infer<typeof PubchemSearchCompoundByIdentifierOutputSchema>;
+/**
+ * Core logic for the `pubchem_search_compound_by_identifier` tool.
+ * It searches for PubChem Compound IDs (CIDs) using a common chemical identifier.
+ *
+ * @param {PubchemSearchCompoundByIdentifierInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemSearchCompoundByIdentifierOutput>} A promise that resolves with the search results.
+ * @throws {McpError} Throws a structured error if the API request fails, the identifier is not found, or the response is malformed.
+ */
+export declare function pubchemSearchCompoundByIdentifierLogic(params: PubchemSearchCompoundByIdentifierInput, context: RequestContext): Promise<PubchemSearchCompoundByIdentifierOutput>;

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

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_search_compound_by_identifier` tool.
+ * @module src/mcp-server/tools/searchCompoundByIdentifier/logic
+ */
+import { z } from "zod";
+import { pubChemApiClient } from "../../../services/pubchem/pubchemApiClient.js";
+import { logger } from "../../../utils/index.js";
+// 1. Define and export the Zod schema for input validation
+export const PubchemSearchCompoundByIdentifierInputSchema = z.object({
+    identifierType: z
+        .enum(["name", "smiles", "inchikey"])
+        .describe("The type of chemical identifier being provided."),
+    identifiers: z
+        .array(z.string().min(1, "Identifier cannot be empty."))
+        .min(1, "At least one identifier must be provided.")
+        .describe("An array of identifier strings. Examples: ['aspirin', 'ibuprofen'] for name."),
+});
+// 3. Define and export the Zod schema for the tool's output
+export const PubchemSearchCompoundByIdentifierOutputSchema = z.object({
+    results: z
+        .record(z.array(z.number().int()))
+        .describe("An object mapping each input identifier to an array of matching PubChem Compound IDs (CIDs)."),
+});
+/**
+ * Core logic for the `pubchem_search_compound_by_identifier` tool.
+ * It searches for PubChem Compound IDs (CIDs) using a common chemical identifier.
+ *
+ * @param {PubchemSearchCompoundByIdentifierInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemSearchCompoundByIdentifierOutput>} A promise that resolves with the search results.
+ * @throws {McpError} Throws a structured error if the API request fails, the identifier is not found, or the response is malformed.
+ */
+export async function pubchemSearchCompoundByIdentifierLogic(params, context) {
+    logger.debug("Processing pubchem_search_compound_by_identifier logic...", {
+        ...context,
+        params,
+    });
+    const { identifierType, identifiers } = params;
+    const results = {};
+    const promises = identifiers.map(async (identifier) => {
+        const path = `/compound/${identifierType}/${encodeURIComponent(identifier)}/cids/JSON`;
+        try {
+            const response = await pubChemApiClient.get(path, context);
+            if (response?.IdentifierList?.CID) {
+                results[identifier] = response.IdentifierList.CID;
+            }
+            else {
+                results[identifier] = [];
+            }
+        }
+        catch (error) {
+            logger.warning(`API call failed for identifier '${identifier}'. It will be omitted from the results.`, { ...context, error });
+            results[identifier] = [];
+        }
+    });
+    await Promise.all(promises);
+    logger.info(`Completed search for ${identifiers.length} identifiers.`, context);
+    return { results };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_search_compound_by_identifier` tool.
+ * @module src/mcp-server/tools/searchCompoundByIdentifier/registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers the 'pubchem_search_compound_by_identifier' tool with the MCP server.
+ * This tool searches for a PubChem Compound ID (CID) using a common chemical identifier.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export declare const registerPubchemSearchCompoundByIdentifierTool: (server: McpServer) => Promise<void>;

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

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Handles the registration of the `pubchem_search_compound_by_identifier` tool.
+ * @module src/mcp-server/tools/searchCompoundByIdentifier/registration
+ */
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { PubchemSearchCompoundByIdentifierInputSchema, pubchemSearchCompoundByIdentifierLogic, } from "./logic.js";
+/**
+ * Registers the 'pubchem_search_compound_by_identifier' tool with the MCP server.
+ * This tool searches for a PubChem Compound ID (CID) using a common chemical identifier.
+ *
+ * @param {McpServer} server - The MCP server instance to register the tool with.
+ */
+export const registerPubchemSearchCompoundByIdentifierTool = async (server) => {
+    const toolName = "pubchem_search_compound_by_identifier";
+    const toolDescription = "Searches for PubChem Compound IDs (CIDs) using a list of common chemical identifiers like names (e.g., ['aspirin', 'ibuprofen']), SMILES strings, or InChIKeys. This is the first step for most compound-related workflows.";
+    server.tool(toolName, toolDescription, PubchemSearchCompoundByIdentifierInputSchema.shape, async (params, mcpContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            operation: "HandleToolRequest",
+            toolName,
+            mcpToolContext: mcpContext,
+            input: params,
+        });
+        try {
+            logger.info(`Initiating tool request for ${toolName} for identifiers: '${params.identifiers.join(", ")}'`, handlerContext);
+            const result = await pubchemSearchCompoundByIdentifierLogic(params, handlerContext);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            const handledError = ErrorHandler.handleError(error, {
+                operation: "pubchemSearchCompoundByIdentifierToolHandler",
+                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,
+            };
+        }
+    });
+};

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

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

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

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

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

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `pubchem_search_compounds_by_formula` tool.
+ * @module src/mcp-server/tools/searchCompoundsByFormula/logic
+ */
+import { z } from "zod";
+import { type RequestContext } from "../../../utils/index.js";
+export declare const PubchemSearchCompoundsByFormulaInputSchema: z.ZodObject<{
+    formula: z.ZodString;
+    allowOtherElements: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRecords: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    maxRecords: number;
+    formula: string;
+    allowOtherElements: boolean;
+}, {
+    formula: string;
+    maxRecords?: number | undefined;
+    allowOtherElements?: boolean | undefined;
+}>;
+export type PubchemSearchCompoundsByFormulaInput = z.infer<typeof PubchemSearchCompoundsByFormulaInputSchema>;
+export declare const PubchemSearchCompoundsByFormulaOutputSchema: z.ZodObject<{
+    cids: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    cids: number[];
+}, {
+    cids: number[];
+}>;
+export type PubchemSearchCompoundsByFormulaOutput = z.infer<typeof PubchemSearchCompoundsByFormulaOutputSchema>;
+/**
+ * Core logic for the `pubchem_search_compounds_by_formula` tool. It finds compounds
+ * that match a given molecular formula.
+ *
+ * @param {PubchemSearchCompoundsByFormulaInput} params - The validated input parameters.
+ * @param {RequestContext} context - The request context for logging and tracing.
+ * @returns {Promise<PubchemSearchCompoundsByFormulaOutput>} A promise that resolves with a list of matching CIDs.
+ * @throws {McpError} Throws a structured error if the API request fails or returns a fault.
+ */
+export declare function pubchemSearchCompoundsByFormulaLogic(params: PubchemSearchCompoundsByFormulaInput, context: RequestContext): Promise<PubchemSearchCompoundsByFormulaOutput>;