@forestadmin/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMcpRoute = exports.MCP_PATHS = exports.ForestMCPServer = void 0;
+// Library exports only - no side effects
+var server_1 = require("./server");
+Object.defineProperty(exports, "ForestMCPServer", { enumerable: true, get: function () { return __importDefault(server_1).default; } });
+var mcp_paths_1 = require("./mcp-paths");
+Object.defineProperty(exports, "MCP_PATHS", { enumerable: true, get: function () { return mcp_paths_1.MCP_PATHS; } });
+Object.defineProperty(exports, "isMcpRoute", { enumerable: true, get: function () { return mcp_paths_1.isMcpRoute; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEseUNBQXlDO0FBQ3pDLG1DQUFzRDtBQUE3QywwSEFBQSxPQUFPLE9BQW1CO0FBRW5DLHlDQUFvRDtBQUEzQyxzR0FBQSxTQUFTLE9BQUE7QUFBRSx1R0FBQSxVQUFVLE9BQUEifQ==

package/dist/mcp-paths.d.ts

@@ -0,0 +1,5 @@
+/** MCP-specific paths that should be handled by the MCP server */
+export declare const MCP_PATHS: string[];
+/** Check if a URL is an MCP route */
+export declare function isMcpRoute(url: string): boolean;
+//# sourceMappingURL=mcp-paths.d.ts.map

package/dist/mcp-paths.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_PATHS = void 0;
+exports.isMcpRoute = isMcpRoute;
+/** MCP-specific paths that should be handled by the MCP server */
+exports.MCP_PATHS = ['/.well-known/', '/oauth/', '/mcp'];
+/** Check if a URL is an MCP route */
+function isMcpRoute(url) {
+    return exports.MCP_PATHS.some(p => url === p || url.startsWith(p));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWNwLXBhdGhzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL21jcC1wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxnQ0FFQztBQU5ELGtFQUFrRTtBQUNyRCxRQUFBLFNBQVMsR0FBRyxDQUFDLGVBQWUsRUFBRSxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFFOUQscUNBQXFDO0FBQ3JDLFNBQWdCLFVBQVUsQ0FBQyxHQUFXO0lBQ3BDLE9BQU8saUJBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxJQUFJLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUM3RCxDQUFDIn0=

package/dist/polyfills.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Polyfill for URL.canParse
+ *
+ * The MCP SDK's OAuth handler uses URL.canParse in Zod schema validation.
+ * Some environments (like certain Koa/Express proxy setups) may have a different
+ * URL implementation that doesn't include the canParse static method
+ * (added in Node.js 19.9.0 / 20.0.0).
+ *
+ * This polyfill must be imported BEFORE any MCP SDK imports.
+ */
+export {};
+//# sourceMappingURL=polyfills.d.ts.map

package/dist/polyfills.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Polyfill for URL.canParse
+ *
+ * The MCP SDK's OAuth handler uses URL.canParse in Zod schema validation.
+ * Some environments (like certain Koa/Express proxy setups) may have a different
+ * URL implementation that doesn't include the canParse static method
+ * (added in Node.js 19.9.0 / 20.0.0).
+ *
+ * This polyfill must be imported BEFORE any MCP SDK imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Check if URL.canParse exists on the global URL
+if (typeof URL.canParse !== 'function') {
+    // Provide a fallback polyfill implementation
+    URL.canParse = (url, base) => {
+        try {
+            // eslint-disable-next-line no-new
+            new URL(url, base);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9seWZpbGxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3BvbHlmaWxscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7OztHQVNHOztBQUVILGlEQUFpRDtBQUNqRCxJQUFJLE9BQU8sR0FBRyxDQUFDLFFBQVEsS0FBSyxVQUFVLEVBQUUsQ0FBQztJQUN2Qyw2Q0FBNkM7SUFDNUMsR0FBd0UsQ0FBQyxRQUFRLEdBQUcsQ0FDbkYsR0FBVyxFQUNYLElBQWEsRUFDSixFQUFFO1FBQ1gsSUFBSSxDQUFDO1lBQ0gsa0NBQWtDO1lBQ2xDLElBQUksR0FBRyxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUVuQixPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7SUFDSCxDQUFDLENBQUM7QUFDSixDQUFDIn0=

package/dist/schemas/filter.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+declare const _default: Readonly<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+export default _default;
+//# sourceMappingURL=filter.d.ts.map

package/dist/schemas/filter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const operatorEnum = zod_1.z.enum([
+    'Equal',
+    'NotEqual',
+    'LessThan',
+    'GreaterThan',
+    'LessThanOrEqual',
+    'GreaterThanOrEqual',
+    'Match',
+    'NotContains',
+    'NotIContains',
+    'LongerThan',
+    'ShorterThan',
+    'IncludesAll',
+    'IncludesNone',
+    'Today',
+    'Yesterday',
+    'PreviousMonth',
+    'PreviousQuarter',
+    'PreviousWeek',
+    'PreviousYear',
+    'PreviousMonthToDate',
+    'PreviousQuarterToDate',
+    'PreviousWeekToDate',
+    'PreviousXDaysToDate',
+    'PreviousXDays',
+    'PreviousYearToDate',
+    'Present',
+    'Blank',
+    'Missing',
+    'In',
+    'NotIn',
+    'StartsWith',
+    'EndsWith',
+    'Contains',
+    'IStartsWith',
+    'IEndsWith',
+    'IContains',
+    'Like',
+    'ILike',
+    'Before',
+    'After',
+    'AfterXHoursAgo',
+    'BeforeXHoursAgo',
+    'Future',
+    'Past',
+]);
+const aggregatorEnum = zod_1.z.enum(['And', 'Or']);
+// Leaf condition (e.g., { field: 'name', operator: 'Equal', value: 'John' })
+const leafSchema = zod_1.z.object({
+    field: zod_1.z.string(),
+    operator: operatorEnum,
+    value: zod_1.z.unknown().optional(),
+});
+// Build nested branch schemas iteratively (avoids z.lazy() which causes $ref issues)
+const MAX_NESTING_DEPTH = 3;
+let conditionSchema = leafSchema;
+for (let i = 0; i < MAX_NESTING_DEPTH; i += 1) {
+    conditionSchema = zod_1.z.union([
+        leafSchema,
+        zod_1.z.object({
+            aggregator: aggregatorEnum,
+            conditions: zod_1.z.array(conditionSchema),
+        }),
+    ]);
+}
+exports.default = Object.freeze(conditionSchema);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NjaGVtYXMvZmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNkJBQXdCO0FBRXhCLE1BQU0sWUFBWSxHQUFHLE9BQUMsQ0FBQyxJQUFJLENBQUM7SUFDMUIsT0FBTztJQUNQLFVBQVU7SUFDVixVQUFVO0lBQ1YsYUFBYTtJQUNiLGlCQUFpQjtJQUNqQixvQkFBb0I7SUFDcEIsT0FBTztJQUNQLGFBQWE7SUFDYixjQUFjO0lBQ2QsWUFBWTtJQUNaLGFBQWE7SUFDYixhQUFhO0lBQ2IsY0FBYztJQUNkLE9BQU87SUFDUCxXQUFXO0lBQ1gsZUFBZTtJQUNmLGlCQUFpQjtJQUNqQixjQUFjO0lBQ2QsY0FBYztJQUNkLHFCQUFxQjtJQUNyQix1QkFBdUI7SUFDdkIsb0JBQW9CO0lBQ3BCLHFCQUFxQjtJQUNyQixlQUFlO0lBQ2Ysb0JBQW9CO0lBQ3BCLFNBQVM7SUFDVCxPQUFPO0lBQ1AsU0FBUztJQUNULElBQUk7SUFDSixPQUFPO0lBQ1AsWUFBWTtJQUNaLFVBQVU7SUFDVixVQUFVO0lBQ1YsYUFBYTtJQUNiLFdBQVc7SUFDWCxXQUFXO0lBQ1gsTUFBTTtJQUNOLE9BQU87SUFDUCxRQUFRO0lBQ1IsT0FBTztJQUNQLGdCQUFnQjtJQUNoQixpQkFBaUI7SUFDakIsUUFBUTtJQUNSLE1BQU07Q0FDUCxDQUFDLENBQUM7QUFFSCxNQUFNLGNBQWMsR0FBRyxPQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7QUFFN0MsNkVBQTZFO0FBQzdFLE1BQU0sVUFBVSxHQUFHLE9BQUMsQ0FBQyxNQUFNLENBQUM7SUFDMUIsS0FBSyxFQUFFLE9BQUMsQ0FBQyxNQUFNLEVBQUU7SUFDakIsUUFBUSxFQUFFLFlBQVk7SUFDdEIsS0FBSyxFQUFFLE9BQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLEVBQUU7Q0FDOUIsQ0FBQyxDQUFDO0FBRUgscUZBQXFGO0FBQ3JGLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxDQUFDO0FBRTVCLElBQUksZUFBZSxHQUFpQixVQUFVLENBQUM7QUFFL0MsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLGlCQUFpQixFQUFFLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztJQUM5QyxlQUFlLEdBQUcsT0FBQyxDQUFDLEtBQUssQ0FBQztRQUN4QixVQUFVO1FBQ1YsT0FBQyxDQUFDLE1BQU0sQ0FBQztZQUNQLFVBQVUsRUFBRSxjQUFjO1lBQzFCLFVBQVUsRUFBRSxPQUFDLENBQUMsS0FBSyxDQUFDLGVBQWUsQ0FBQztTQUNyQyxDQUFDO0tBQ0gsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVELGtCQUFlLE1BQU0sQ0FBQyxNQUFNLENBQUMsZUFBZSxDQUFDLENBQUMifQ==

package/dist/schemas/filter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=filter.test.d.ts.map

package/dist/schemas/filter.test.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_1 = __importDefault(require("./filter"));
+describe('filterSchema', () => {
+    describe('leaf conditions', () => {
+        it('should accept valid leaf condition with Equal operator', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'name', operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept leaf condition without value for operators that do not require it', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'deletedAt', operator: 'Present' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it.each([
+            'Equal',
+            'NotEqual',
+            'LessThan',
+            'GreaterThan',
+            'LessThanOrEqual',
+            'GreaterThanOrEqual',
+            'Match',
+            'NotContains',
+            'NotIContains',
+            'LongerThan',
+            'ShorterThan',
+            'IncludesAll',
+            'IncludesNone',
+            'Today',
+            'Yesterday',
+            'PreviousMonth',
+            'PreviousQuarter',
+            'PreviousWeek',
+            'PreviousYear',
+            'PreviousMonthToDate',
+            'PreviousQuarterToDate',
+            'PreviousWeekToDate',
+            'PreviousXDaysToDate',
+            'PreviousXDays',
+            'PreviousYearToDate',
+            'Present',
+            'Blank',
+            'Missing',
+            'In',
+            'NotIn',
+            'StartsWith',
+            'EndsWith',
+            'Contains',
+            'IStartsWith',
+            'IEndsWith',
+            'IContains',
+            'Like',
+            'ILike',
+            'Before',
+            'After',
+            'AfterXHoursAgo',
+            'BeforeXHoursAgo',
+            'Future',
+            'Past',
+        ])('should accept operator "%s"', operator => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'testField', operator, value: 'test' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should reject invalid operator', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'name', operator: 'InvalidOperator', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).toThrow();
+        });
+        it('should require field property', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).toThrow();
+        });
+        it('should require operator property', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'name', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).toThrow();
+        });
+    });
+    describe('branch conditions', () => {
+        it('should accept And aggregator', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'name', operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept Or aggregator', () => {
+            const condition = {
+                aggregator: 'Or',
+                conditions: [{ field: 'name', operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should reject invalid aggregator', () => {
+            const condition = {
+                aggregator: 'Xor',
+                conditions: [{ field: 'name', operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).toThrow();
+        });
+        it('should require conditions array', () => {
+            const condition = {
+                aggregator: 'And',
+            };
+            expect(() => filter_1.default.parse(condition)).toThrow();
+        });
+        it('should accept empty conditions array', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+    });
+    describe('nested conditions', () => {
+        it('should accept nested branch conditions', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [
+                    { field: 'name', operator: 'Equal', value: 'John' },
+                    {
+                        aggregator: 'Or',
+                        conditions: [
+                            { field: 'age', operator: 'GreaterThan', value: 18 },
+                            { field: 'status', operator: 'Equal', value: 'adult' },
+                        ],
+                    },
+                ],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept deeply nested conditions', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [
+                    {
+                        aggregator: 'Or',
+                        conditions: [
+                            {
+                                aggregator: 'And',
+                                conditions: [
+                                    { field: 'a', operator: 'Equal', value: 1 },
+                                    { field: 'b', operator: 'Equal', value: 2 },
+                                ],
+                            },
+                            { field: 'c', operator: 'Equal', value: 3 },
+                        ],
+                    },
+                ],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept mixed leaf and branch conditions', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [
+                    { field: 'active', operator: 'Equal', value: true },
+                    {
+                        aggregator: 'Or',
+                        conditions: [
+                            { field: 'role', operator: 'Equal', value: 'admin' },
+                            { field: 'role', operator: 'Equal', value: 'superuser' },
+                        ],
+                    },
+                    { field: 'verified', operator: 'Equal', value: true },
+                ],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+    });
+    describe('value types', () => {
+        it('should accept string values', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'name', operator: 'Equal', value: 'John' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept number values', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'age', operator: 'GreaterThan', value: 25 }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept boolean values', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'active', operator: 'Equal', value: true }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept null values', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'deletedAt', operator: 'Equal', value: null }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept array values for In operator', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'status', operator: 'In', value: ['active', 'pending', 'approved'] }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+        it('should accept date string values', () => {
+            const condition = {
+                aggregator: 'And',
+                conditions: [{ field: 'createdAt', operator: 'After', value: '2024-01-01T00:00:00Z' }],
+            };
+            expect(() => filter_1.default.parse(condition)).not.toThrow();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.test.js","sourceRoot":"","sources":["../../src/schemas/filter.test.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,87 @@
+import './polyfills';
+import type { Express } from 'express';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import * as http from 'http';
+export type LogLevel = 'Debug' | 'Info' | 'Warn' | 'Error';
+export type Logger = (level: LogLevel, message: string) => void;
+export type HttpCallback = (req: http.IncomingMessage, res: http.ServerResponse, next?: () => void) => void;
+/**
+ * Options for configuring the Forest Admin MCP Server
+ */
+export interface ForestMCPServerOptions {
+    /** Forest Admin server URL */
+    forestServerUrl?: string;
+    /** Forest Admin app URL (for OAuth redirects) */
+    forestAppUrl?: string;
+    /** Forest Admin environment secret */
+    envSecret?: string;
+    /** Forest Admin authentication secret */
+    authSecret?: string;
+    /** Optional logger function. Defaults to console logging. */
+    logger?: Logger;
+}
+/**
+ * Forest Admin MCP Server
+ *
+ * This server provides HTTP REST API access to Forest Admin operations
+ * with OAuth authentication support.
+ *
+ * Environment Variables (used as fallback when options not provided):
+ * - FOREST_ENV_SECRET: Your Forest Admin environment secret (required)
+ * - FOREST_AUTH_SECRET: Your Forest Admin authentication secret, it must be the same one as the one on your agent (required)
+ * - FOREST_SERVER_URL: Forest Admin server URL (optional)
+ * - MCP_SERVER_PORT: Port for the HTTP server (default: 3931)
+ */
+export default class ForestMCPServer {
+    mcpServer: McpServer;
+    mcpTransport?: StreamableHTTPServerTransport;
+    httpServer?: http.Server;
+    expressApp?: Express;
+    forestServerUrl: string;
+    forestAppUrl: string;
+    private envSecret?;
+    private authSecret?;
+    private logger;
+    constructor(options?: ForestMCPServerOptions);
+    private setupTools;
+    private ensureSecretsAreSet;
+    /**
+     * Filters tool arguments to only include non-sensitive fields for logging.
+     * Prevents accidentally logging sensitive data like search queries or filters.
+     */
+    private filterArgsForLogging;
+    /**
+     * Logs tool call information if the request is a tools/call method.
+     */
+    private logToolCallIfPresent;
+    /**
+     * Handles an incoming MCP request.
+     * Logs the request, intercepts the response for error logging, and delegates to the transport.
+     */
+    private handleMcpRequest;
+    /**
+     * Build and return the Express app without starting a standalone server.
+     * Useful for embedding the MCP server into another application.
+     *
+     * @param baseUrl - Optional base URL override. If not provided, will use the
+     *                  environmentApiEndpoint from Forest Admin API.
+     * @returns The configured Express application
+     */
+    buildExpressApp(baseUrl?: URL): Promise<Express>;
+    /**
+     * Build and return an HTTP callback that can be used as middleware.
+     * The callback will handle MCP-related routes (/.well-known/*, /oauth/*, /mcp)
+     * and call next() for other routes.
+     *
+     * @param baseUrl - Optional base URL override. If not provided, will use the
+     *                  environmentApiEndpoint from Forest Admin API.
+     * @returns An HTTP callback function
+     */
+    getHttpCallback(baseUrl?: URL): Promise<HttpCallback>;
+    /**
+     * Run the MCP server as a standalone HTTP server.
+     */
+    run(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map