@cyanheads/pubmed-mcp-server 1.0.12

package/dist/mcp-server/resources/echoResource/echoResourceLogic.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the `echo` resource.
+ * This module includes a Zod schema for query parameter validation, type definitions,
+ * and the main processing function that constructs the resource response.
+ * The echo resource is designed to return a message, typically extracted from the
+ * request URI's path or query parameters, along with a timestamp.
+ * @module src/mcp-server/resources/echoResource/echoResourceLogic
+ */
+import { z } from "zod";
+import { logger } from "../../../utils/index.js";
+/**
+ * Zod schema defining expected query parameters for the echo resource.
+ *
+ * This schema is intended for validating parameters passed via the URI's query string
+ * (e.g., `echo://some_message?message=override_from_query&anotherParam=value`).
+ * Path parameters, such as `{message}` in a template like `echo://{message}`,
+ * are typically defined in the `ResourceTemplate` (see `registration.ts`) and
+ * extracted by the MCP SDK from the URI path. The SDK merges these path
+ * parameters into the `params` object passed to the handler.
+ *
+ * If a path parameter and a query parameter share the same name (e.g., 'message'),
+ * the query parameter will take precedence over the path parameter. This schema
+ * defines `message` as an optional query parameter.
+ */
+export const EchoResourceQuerySchema = z.object({
+    /**
+     * Optional message to be echoed back in the response.
+     * If the resource template also defines a 'message' path parameter,
+     * this query parameter will override the path parameter's value if both are present.
+     */
+    message: z
+        .string()
+        .optional()
+        .describe("Optional message to echo back in the response. If not provided, a default may be used or derived from the path."),
+});
+/**
+ * Processes the core logic for an echo resource request.
+ * It constructs a response payload containing a message (derived from path or query parameters),
+ * the current timestamp, and the original request URI.
+ *
+ * The `params` argument is expected to contain validated query parameters. If the resource
+ * template (e.g., `echo://{message}`) includes path parameters, the MCP SDK extracts
+ * them and merges them into the `params` object. If a query parameter shares the same
+ * name as a path parameter, the query parameter's value takes precedence. This function
+ * assumes `params.message` will hold the definitive message.
+ *
+ * @param uri - The full URL object of the incoming resource request.
+ * @param params - The validated query parameters for the request.
+ *   This object also includes path parameters merged by the SDK, with query parameters
+ *   taking precedence in case of name conflicts.
+ * @param context - The request context, used for logging and tracing the operation.
+ * @returns The data payload for the response.
+ *   This payload is typically JSON-stringified by the calling handler.
+ */
+export const processEchoResource = (uri, params, context) => {
+    // The `params.message` can originate from a query parameter (validated by `EchoResourceQuerySchema`)
+    // or a path parameter (e.g., from a template like `echo://{message_from_path}`).
+    // The MCP SDK merges these, with query parameters taking precedence over path parameters if names conflict.
+    // The fallback "Default message..." is a safeguard if no message is provided via path or query.
+    const messageToEcho = params.message || `Default echo from ${uri.pathname}`;
+    logger.debug("Processing echo resource logic.", {
+        ...context,
+        resourceUri: uri.href,
+        extractedMessage: messageToEcho,
+        queryParamMessage: params.message,
+    });
+    const responsePayload = {
+        message: messageToEcho,
+        timestamp: new Date().toISOString(),
+        requestUri: uri.href,
+    };
+    logger.debug("Echo resource processed successfully.", {
+        ...context,
+        responsePayloadSummary: {
+            messageLength: responsePayload.message.length,
+            uriEchoed: responsePayload.requestUri.length > 50
+                ? `${responsePayload.requestUri.substring(0, 47)}...`
+                : responsePayload.requestUri,
+        },
+    });
+    return responsePayload;
+};

package/dist/mcp-server/resources/echoResource/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Barrel file for the `echo` resource.
+ * This file serves as the public interface for the echo resource module,
+ * primarily exporting the `registerEchoResource` function. This function is
+ * responsible for registering the echo resource, including its templates and handler,
+ * with an MCP server instance. This makes the resource accessible to clients
+ * via defined URI patterns.
+ *
+ * Consuming modules should import from this barrel file to access
+ * the echo resource's registration capabilities.
+ * @module src/mcp-server/resources/echoResource/index
+ */
+export { registerEchoResource } from "./registration.js";

package/dist/mcp-server/resources/echoResource/index.js

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Barrel file for the `echo` resource.
+ * This file serves as the public interface for the echo resource module,
+ * primarily exporting the `registerEchoResource` function. This function is
+ * responsible for registering the echo resource, including its templates and handler,
+ * with an MCP server instance. This makes the resource accessible to clients
+ * via defined URI patterns.
+ *
+ * Consuming modules should import from this barrel file to access
+ * the echo resource's registration capabilities.
+ * @module src/mcp-server/resources/echoResource/index
+ */
+export { registerEchoResource } from "./registration.js";

package/dist/mcp-server/resources/echoResource/registration.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Handles the registration of the `echo` resource with an MCP server instance.
+ * This module defines the resource's template (URI structure), metadata (name, description, examples),
+ * and the asynchronous handler function that processes `resources/read` requests matching the template.
+ * It utilizes the MCP SDK's `server.resource()` method for registration and integrates
+ * robust error handling using the project's `ErrorHandler` utility.
+ * @module src/mcp-server/resources/echoResource/registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Registers the 'echo' resource and its handlers with the provided MCP server instance.
+ *
+ * This function defines:
+ * 1.  The resource template (e.g., `echo://{message}`), which determines the URI structure.
+ *     The `{message}` part is a path variable.
+ * 2.  A `list` operation for the template to provide example/discoverable URIs.
+ * 3.  Metadata for the resource, including its user-friendly name, description, MIME type,
+ *     and example URIs.
+ * 4.  The core asynchronous handler logic for `resources/read` requests that match the template.
+ *     This handler processes the request and returns the resource content.
+ *
+ * Error handling is integrated throughout using `ErrorHandler.tryCatch` for robustness.
+ *
+ * @param server - The MCP server instance to register the resource with.
+ * @returns A promise that resolves when the resource registration is complete. It does not return a value upon successful completion.
+ * @throws {McpError} If the registration process fails critically, which might halt server startup.
+ * @see {@link EchoResourceParams} for the type of parameters passed to the handler.
+ * @see {@link processEchoResource} for the core resource logic.
+ */
+export declare const registerEchoResource: (server: McpServer) => Promise<void>;

package/dist/mcp-server/resources/echoResource/registration.js

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview Handles the registration of the `echo` resource with an MCP server instance.
+ * This module defines the resource's template (URI structure), metadata (name, description, examples),
+ * and the asynchronous handler function that processes `resources/read` requests matching the template.
+ * It utilizes the MCP SDK's `server.resource()` method for registration and integrates
+ * robust error handling using the project's `ErrorHandler` utility.
+ * @module src/mcp-server/resources/echoResource/registration
+ */
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
+import { processEchoResource, } from "./echoResourceLogic.js";
+/**
+ * Registers the 'echo' resource and its handlers with the provided MCP server instance.
+ *
+ * This function defines:
+ * 1.  The resource template (e.g., `echo://{message}`), which determines the URI structure.
+ *     The `{message}` part is a path variable.
+ * 2.  A `list` operation for the template to provide example/discoverable URIs.
+ * 3.  Metadata for the resource, including its user-friendly name, description, MIME type,
+ *     and example URIs.
+ * 4.  The core asynchronous handler logic for `resources/read` requests that match the template.
+ *     This handler processes the request and returns the resource content.
+ *
+ * Error handling is integrated throughout using `ErrorHandler.tryCatch` for robustness.
+ *
+ * @param server - The MCP server instance to register the resource with.
+ * @returns A promise that resolves when the resource registration is complete. It does not return a value upon successful completion.
+ * @throws {McpError} If the registration process fails critically, which might halt server startup.
+ * @see {@link EchoResourceParams} for the type of parameters passed to the handler.
+ * @see {@link processEchoResource} for the core resource logic.
+ */
+export const registerEchoResource = async (server) => {
+    const resourceName = "echo-resource"; // Internal identifier for this resource registration.
+    const registrationContext = requestContextService.createRequestContext({
+        operation: "RegisterResource",
+        resourceName: resourceName,
+        moduleName: "EchoResourceRegistration",
+    });
+    logger.info(`Attempting to register resource: '${resourceName}'`, registrationContext);
+    await ErrorHandler.tryCatch(async () => {
+        // Define the resource template. This specifies the URI structure and supported operations.
+        // The URI `echo://{message}` uses RFC 6570 syntax, where `{message}` is a path variable.
+        const template = new ResourceTemplate("echo://{message}", {
+            /**
+             * Asynchronous handler for the `resources/list` operation associated with this template.
+             * It provides a list of example or discoverable resource URIs that match this template.
+             * This allows clients to discover how to interact with the echo resource.
+             *
+             * @returns A promise resolving to an object containing an array of resource descriptors.
+             */
+            list: async () => {
+                const listContext = requestContextService.createRequestContext({
+                    parentContext: registrationContext,
+                    operation: "ListEchoResourceExamples",
+                });
+                logger.debug("Executing list operation for echo resource template.", listContext);
+                // Return a static list of example URIs.
+                return {
+                    resources: [
+                        {
+                            uri: "echo://hello",
+                            name: "Default Echo Message",
+                            description: "A simple echo resource example using a default message.",
+                        },
+                        // Add more examples as needed
+                    ],
+                    // nextCursor could be used here if the list were paginated.
+                };
+            },
+            // The `complete` operation (for URI completion suggestions) is optional and not implemented here.
+        });
+        logger.debug(`Resource template created for '${resourceName}': ${template.uriTemplate}`, registrationContext);
+        // Register the resource with the server.
+        // This involves providing the registration name, the template, metadata, and the handler for read operations.
+        server.resource(resourceName, template, {
+            name: "Echo Message Resource",
+            description: "A simple echo resource that returns a message, optionally specified in the URI path.",
+            mimeType: "application/json",
+            examples: [
+                {
+                    name: "Basic echo",
+                    uri: "echo://hello",
+                    description: "Accesses the echo resource to echo the message 'hello'.",
+                },
+                {
+                    name: "Custom echo",
+                    uri: "echo://custom-message-here",
+                    description: "Accesses the echo resource to echo 'custom-message-here'.",
+                },
+            ],
+        }, 
+        /**
+         * Asynchronous handler for `resources/read` requests matching the `echo://{message}` template.
+         * This function is invoked by the MCP SDK when a client requests to read a resource
+         * whose URI matches the registered template.
+         *
+         * The SDK extracts path variables (like `{message}` from `echo://{message}`) from the URI.
+         * These path variables, along with any validated query parameters, are passed in the `params` object.
+         *
+         * @param uri - The full URL object of the resource being requested.
+         * @param params - An object containing parameters derived from the request.
+         *   For this resource, it's expected to include `message` extracted from the URI
+         *   path by the SDK. It conforms to {@link EchoResourceParams}.
+         * @returns A promise that resolves with the resource content, formatted as a `ReadResourceResult`.
+         *   This includes the URI, Base64 encoded content blob, and MIME type.
+         *   If an error is thrown from this handler, the SDK is responsible for catching it and
+         *   formatting an error response.
+         */
+        async (uri, params) => {
+            const handlerContext = requestContextService.createRequestContext({
+                parentContext: registrationContext,
+                operation: "HandleResourceRead",
+                resourceName: resourceName,
+                resourceUri: uri.href,
+                inputParamsSummary: params.message
+                    ? { messageLength: params.message.length }
+                    : { noMessageParam: true },
+            });
+            logger.debug(`Handling read request for resource '${resourceName}', URI: ${uri.href}`, handlerContext);
+            return await ErrorHandler.tryCatch(async () => {
+                const responseData = processEchoResource(uri, params, handlerContext);
+                logger.debug(`'${resourceName}' (URI: ${uri.href}) processed successfully. Preparing content.`, handlerContext);
+                // Construct the `ReadResourceResult` as expected by the MCP SDK.
+                // The content (blob) must be Base64 encoded.
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            blob: Buffer.from(JSON.stringify(responseData)).toString("base64"),
+                            mimeType: "application/json",
+                        },
+                    ],
+                };
+            }, {
+                operation: `ExecutingCoreLogicFor_${resourceName}_Read`,
+                context: handlerContext,
+                input: { uri: uri.href, params },
+                errorMapper: (error) => {
+                    const baseErrorCode = error instanceof McpError
+                        ? error.code
+                        : BaseErrorCode.INTERNAL_ERROR;
+                    const errorMessage = `Error processing read request for resource '${uri.href}': ${error instanceof Error ? error.message : "An unknown error occurred"}`;
+                    return new McpError(baseErrorCode, errorMessage, {
+                        ...handlerContext,
+                        originalErrorName: error instanceof Error ? error.name : typeof error,
+                    });
+                },
+            });
+        });
+        logger.info(`Resource '${resourceName}' (template: '${template.uriTemplate}') registered successfully.`, registrationContext);
+    }, {
+        operation: `RegisteringResource_${resourceName}`,
+        context: registrationContext,
+        errorCode: BaseErrorCode.INITIALIZATION_FAILED,
+        errorMapper: (error) => {
+            const errorMessage = `Failed to register resource '${resourceName}': ${error instanceof Error ? error.message : "An unknown error occurred during registration."}`;
+            const code = error instanceof McpError
+                ? error.code
+                : BaseErrorCode.INITIALIZATION_FAILED;
+            return new McpError(code, errorMessage, {
+                ...registrationContext,
+                originalErrorName: error instanceof Error ? error.name : typeof error,
+            });
+        },
+        critical: true,
+    });
+};

package/dist/mcp-server/server.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Main entry point for the MCP (Model Context Protocol) server.
+ * This file orchestrates the server's lifecycle:
+ * 1. Initializes the core `McpServer` instance (from `@modelcontextprotocol/sdk`) with its identity and capabilities.
+ * 2. Registers available resources and tools, making them discoverable and usable by clients.
+ * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
+ *    based on configuration.
+ * 4. Handles top-level error management during startup.
+ *
+ * MCP Specification References:
+ * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
+ * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
+ * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
+ * @module src/mcp-server/server
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Main application entry point. Initializes and starts the MCP server.
+ * Orchestrates server startup, transport selection, and top-level error handling.
+ *
+ * MCP Spec Relevance:
+ * - Manages server startup, leading to a server ready for MCP messages.
+ * - Handles critical startup failures, ensuring appropriate process exit.
+ *
+ * @returns For 'stdio', resolves with `McpServer`. For 'http', runs indefinitely.
+ *   Rejects on critical failure, leading to process exit.
+ */
+export declare function initializeAndStartServer(): Promise<void | McpServer>;

package/dist/mcp-server/server.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Main entry point for the MCP (Model Context Protocol) server.
+ * This file orchestrates the server's lifecycle:
+ * 1. Initializes the core `McpServer` instance (from `@modelcontextprotocol/sdk`) with its identity and capabilities.
+ * 2. Registers available resources and tools, making them discoverable and usable by clients.
+ * 3. Selects and starts the appropriate communication transport (stdio or Streamable HTTP)
+ *    based on configuration.
+ * 4. Handles top-level error management during startup.
+ *
+ * MCP Specification References:
+ * - Lifecycle: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/lifecycle.mdx
+ * - Overview (Capabilities): https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/index.mdx
+ * - Transports: https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx
+ * @module src/mcp-server/server
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { config } from "../config/index.js";
+import { ErrorHandler, logger, requestContextService } from "../utils/index.js";
+// import { registerEchoResource } from "./resources/echoResource/index.js"; // To be removed after resource implementations.
+import { registerFetchPubMedContentTool } from "./tools/fetchPubMedContent/index.js";
+import { registerGetPubMedArticleConnectionsTool } from "./tools/getPubMedArticleConnections/index.js";
+import { registerPubMedResearchAgentTool } from "./tools/pubmedResearchAgent/index.js"; // Added import
+import { registerSearchPubMedArticlesTool } from "./tools/searchPubMedArticles/index.js";
+import { startHttpTransport } from "./transports/httpTransport.js";
+import { connectStdioTransport } from "./transports/stdioTransport.js";
+/**
+ * Creates and configures a new instance of the `McpServer`.
+ *
+ * This function defines the server's identity and capabilities as presented
+ * to clients during MCP initialization.
+ *
+ * MCP Spec Relevance:
+ * - Server Identity (`serverInfo`): `name` and `version` are part of `ServerInformation`.
+ * - Capabilities Declaration: Declares supported features (logging, dynamic resources/tools).
+ * - Resource/Tool Registration: Makes capabilities discoverable and invocable.
+ *
+ * Design Note: This factory is called once for 'stdio' transport and per session for 'http' transport.
+ *
+ * @returns A promise resolving with the configured `McpServer` instance.
+ * @throws {Error} If any resource or tool registration fails.
+ * @private
+ */
+async function createMcpServerInstance() {
+    const context = requestContextService.createRequestContext({
+        operation: "createMcpServerInstance",
+    });
+    logger.info("Initializing MCP server instance", context);
+    logger.debug("Instantiating McpServer with capabilities", {
+        ...context,
+        serverInfo: {
+            name: config.mcpServerName,
+            version: config.mcpServerVersion,
+        },
+        capabilities: {
+            logging: {},
+            resources: { listChanged: true },
+            tools: { listChanged: true },
+        },
+    });
+    const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, {
+        capabilities: {
+            logging: {}, // Server can receive logging/setLevel and send notifications/message
+            resources: { listChanged: true }, // Server supports dynamic resource lists
+            tools: { listChanged: true }, // Server supports dynamic tool lists
+        },
+    });
+    try {
+        logger.debug("Registering resources and tools...", context);
+        // IMPORTANT: Keep tool registrations in alphabetical order. Do not remove this comment.
+        await registerFetchPubMedContentTool(server);
+        await registerGetPubMedArticleConnectionsTool(server);
+        await registerPubMedResearchAgentTool(server); // Added new tool registration
+        await registerSearchPubMedArticlesTool(server);
+        // Add other tool/resource registrations here
+        logger.info("Resources and tools registered successfully", context);
+    }
+    catch (err) {
+        logger.error("Failed to register resources/tools", {
+            ...context,
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+        throw err;
+    }
+    return server;
+}
+/**
+ * Selects, sets up, and starts the appropriate MCP transport layer based on configuration.
+ *
+ * MCP Spec Relevance:
+ * - Transport Selection: Uses `config.mcpTransportType` ('stdio' or 'http').
+ * - Transport Connection: Calls dedicated functions for chosen transport.
+ * - Server Instance Lifecycle: Single instance for 'stdio', per-session for 'http'.
+ *
+ * @returns Resolves with `McpServer` for 'stdio', or `void` for 'http'.
+ * @throws {Error} If transport type is unsupported or setup fails.
+ * @private
+ */
+async function startTransport() {
+    const transportType = config.mcpTransportType;
+    const context = requestContextService.createRequestContext({
+        operation: "startTransport",
+        transport: transportType,
+    });
+    logger.info(`Starting transport: ${transportType}`, context);
+    if (transportType === "http") {
+        logger.debug("Delegating to startHttpTransport...", context);
+        // For HTTP, startHttpTransport manages its own lifecycle and server instances per session.
+        await startHttpTransport(createMcpServerInstance, context);
+        return; // HTTP server runs indefinitely, no single server instance returned here.
+    }
+    if (transportType === "stdio") {
+        logger.debug("Creating single McpServer instance for stdio transport...", context);
+        const server = await createMcpServerInstance();
+        logger.debug("Delegating to connectStdioTransport...", context);
+        await connectStdioTransport(server, context);
+        return server; // Return the single server instance for stdio.
+    }
+    // Should not be reached if config validation is effective.
+    logger.fatal(`Unsupported transport type configured: ${transportType}`, context);
+    throw new Error(`Unsupported transport type: ${transportType}. Must be 'stdio' or 'http'.`);
+}
+/**
+ * Main application entry point. Initializes and starts the MCP server.
+ * Orchestrates server startup, transport selection, and top-level error handling.
+ *
+ * MCP Spec Relevance:
+ * - Manages server startup, leading to a server ready for MCP messages.
+ * - Handles critical startup failures, ensuring appropriate process exit.
+ *
+ * @returns For 'stdio', resolves with `McpServer`. For 'http', runs indefinitely.
+ *   Rejects on critical failure, leading to process exit.
+ */
+export async function initializeAndStartServer() {
+    const context = requestContextService.createRequestContext({
+        operation: "initializeAndStartServer",
+    });
+    logger.info("MCP Server initialization sequence started.", context);
+    try {
+        const result = await startTransport();
+        logger.info("MCP Server initialization sequence completed successfully.", context);
+        return result;
+    }
+    catch (err) {
+        logger.fatal("Critical error during MCP server initialization.", {
+            ...context,
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+        // Ensure the error is handled by our centralized handler, which might log more details or perform cleanup.
+        ErrorHandler.handleError(err, {
+            operation: "initializeAndStartServer", // More specific operation
+            context: context, // Pass the existing context
+            critical: true, // This is a critical failure
+        });
+        logger.info("Exiting process due to critical initialization error.", context);
+        process.exit(1); // Exit with a non-zero code to indicate failure.
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the fetch_pubmed_content tool.
+ * Exports the tool's registration function.
+ * @module src/mcp-server/tools/fetchPubMedContent/index
+ */
+export { registerFetchPubMedContentTool } from "./registration.js";

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the fetch_pubmed_content tool.
+ * Exports the tool's registration function.
+ * @module src/mcp-server/tools/fetchPubMedContent/index
+ */
+export { registerFetchPubMedContentTool } from "./registration.js";

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

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Logic for the fetch_pubmed_content MCP tool.
+ * Handles EFetch queries for specific PMIDs and formats the results.
+ * This tool can fetch various details from PubMed including abstracts, full XML,
+ * MEDLINE text, and citation data.
+ * @module src/mcp-server/tools/fetchPubMedContent/logic
+ */
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { RequestContext } from "../../../utils/index.js";
+export declare const FetchPubMedContentInputSchema: z.ZodEffects<z.ZodObject<{
+    pmids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    queryKey: z.ZodOptional<z.ZodString>;
+    webEnv: z.ZodOptional<z.ZodString>;
+    retstart: z.ZodOptional<z.ZodNumber>;
+    retmax: z.ZodOptional<z.ZodNumber>;
+    detailLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<["abstract_plus", "full_xml", "medline_text", "citation_data"]>>>;
+    includeMeshTerms: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeGrantInfo: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    outputFormat: z.ZodDefault<z.ZodOptional<z.ZodEnum<["json", "raw_text"]>>>;
+}, "strip", z.ZodTypeAny, {
+    detailLevel: "abstract_plus" | "full_xml" | "medline_text" | "citation_data";
+    includeMeshTerms: boolean;
+    includeGrantInfo: boolean;
+    outputFormat: "json" | "raw_text";
+    pmids?: string[] | undefined;
+    queryKey?: string | undefined;
+    webEnv?: string | undefined;
+    retstart?: number | undefined;
+    retmax?: number | undefined;
+}, {
+    pmids?: string[] | undefined;
+    queryKey?: string | undefined;
+    webEnv?: string | undefined;
+    retstart?: number | undefined;
+    retmax?: number | undefined;
+    detailLevel?: "abstract_plus" | "full_xml" | "medline_text" | "citation_data" | undefined;
+    includeMeshTerms?: boolean | undefined;
+    includeGrantInfo?: boolean | undefined;
+    outputFormat?: "json" | "raw_text" | undefined;
+}>, {
+    detailLevel: "abstract_plus" | "full_xml" | "medline_text" | "citation_data";
+    includeMeshTerms: boolean;
+    includeGrantInfo: boolean;
+    outputFormat: "json" | "raw_text";
+    pmids?: string[] | undefined;
+    queryKey?: string | undefined;
+    webEnv?: string | undefined;
+    retstart?: number | undefined;
+    retmax?: number | undefined;
+}, {
+    pmids?: string[] | undefined;
+    queryKey?: string | undefined;
+    webEnv?: string | undefined;
+    retstart?: number | undefined;
+    retmax?: number | undefined;
+    detailLevel?: "abstract_plus" | "full_xml" | "medline_text" | "citation_data" | undefined;
+    includeMeshTerms?: boolean | undefined;
+    includeGrantInfo?: boolean | undefined;
+    outputFormat?: "json" | "raw_text" | undefined;
+}>;
+export type FetchPubMedContentInput = z.infer<typeof FetchPubMedContentInputSchema>;
+export declare function fetchPubMedContentLogic(input: FetchPubMedContentInput, parentRequestContext: RequestContext): Promise<CallToolResult>;