@metamask/client-mcp-core 0.1.0

package/dist/mcp-server/tools/definitions.d.cts

@@ -0,0 +1,97 @@
+import type { ZodType } from "zod";
+import type { ToolHandler } from "./batch.cjs";
+export declare const TOOL_PREFIX = "mm";
+export type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+type ZodSchema = ZodType<unknown> & {
+    toJSONSchema(): Record<string, unknown>;
+};
+type ToolEntry = {
+    schema: ZodSchema;
+    description: string;
+    handler: ToolHandler;
+};
+/**
+ * Get all tool definitions with their schemas and descriptions.
+ *
+ * @returns Array of tool definitions for all available MCP tools
+ */
+export declare function getToolDefinitions(): ToolDefinition[];
+/**
+ * Get the handler function for a specific tool by name.
+ *
+ * @param name The tool name (with or without mm_ prefix)
+ * @returns The tool handler function or undefined if tool not found
+ */
+export declare function getToolHandler(name: string): ToolHandler | undefined;
+/**
+ * Check if a tool handler exists for the given tool name.
+ *
+ * @param name The tool name to check
+ * @returns True if a handler exists for the tool, false otherwise
+ */
+export declare function hasToolHandler(name: string): boolean;
+/**
+ * Extract the base name from a tool name by removing the mm_ prefix.
+ *
+ * @param toolName The tool name (with or without mm_ prefix)
+ * @returns The base name without the prefix
+ */
+export declare function extractBaseName(toolName: string): string;
+/**
+ * Validate tool input against the tool's schema and return parsed data.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns The validated and parsed input data
+ */
+export declare function validateToolInput<Type = unknown>(toolName: string, input: unknown): Type;
+/**
+ * Safely validate tool input without throwing errors.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns Object with success flag and either parsed data or error message
+ */
+export declare function safeValidateToolInput(toolName: string, input: unknown): {
+    /**
+     * Indicates validation succeeded
+     */
+    success: true;
+    /**
+     * The validated and parsed input data
+     */
+    data: unknown;
+} | {
+    /**
+     * Indicates validation failed
+     */
+    success: false;
+    /**
+     * Error message describing validation failure
+     */
+    error: string;
+};
+/**
+ * Get all available tool base names (without mm_ prefix).
+ *
+ * @returns Array of tool base names
+ */
+export declare function getToolNames(): string[];
+/**
+ * Get all available tool names with mm_ prefix.
+ *
+ * @returns Array of prefixed tool names
+ */
+export declare function getPrefixedToolNames(): string[];
+/**
+ * Build a record mapping prefixed tool names to their handler functions.
+ *
+ * @returns Record of tool name to handler function mappings
+ */
+export declare function buildToolHandlersRecord(): Record<string, ToolHandler>;
+export type { ToolEntry };
+//# sourceMappingURL=definitions.d.cts.map

package/dist/mcp-server/tools/definitions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.cts","sourceRoot":"","sources":["../../../src/mcp-server/tools/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY;AAiCnC,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAmB;AA0C9C,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAEF,KAAK,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAEhF,KAAK,SAAS,GAAG;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AAwYF;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,cAAc,EAAE,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAUpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAG,OAAO,EAC9C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,IAAI,CASN;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GAEZ;IACE;;OAEG;IACH,OAAO,EAAE,IAAI,CAAC;IACd;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;CACf,GACD;IACE;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC;IACf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf,CAiBJ;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAMrE;AAED,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/mcp-server/tools/definitions.d.mts

@@ -0,0 +1,97 @@
+import type { ZodType } from "zod";
+import type { ToolHandler } from "./batch.mjs";
+export declare const TOOL_PREFIX = "mm";
+export type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+type ZodSchema = ZodType<unknown> & {
+    toJSONSchema(): Record<string, unknown>;
+};
+type ToolEntry = {
+    schema: ZodSchema;
+    description: string;
+    handler: ToolHandler;
+};
+/**
+ * Get all tool definitions with their schemas and descriptions.
+ *
+ * @returns Array of tool definitions for all available MCP tools
+ */
+export declare function getToolDefinitions(): ToolDefinition[];
+/**
+ * Get the handler function for a specific tool by name.
+ *
+ * @param name The tool name (with or without mm_ prefix)
+ * @returns The tool handler function or undefined if tool not found
+ */
+export declare function getToolHandler(name: string): ToolHandler | undefined;
+/**
+ * Check if a tool handler exists for the given tool name.
+ *
+ * @param name The tool name to check
+ * @returns True if a handler exists for the tool, false otherwise
+ */
+export declare function hasToolHandler(name: string): boolean;
+/**
+ * Extract the base name from a tool name by removing the mm_ prefix.
+ *
+ * @param toolName The tool name (with or without mm_ prefix)
+ * @returns The base name without the prefix
+ */
+export declare function extractBaseName(toolName: string): string;
+/**
+ * Validate tool input against the tool's schema and return parsed data.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns The validated and parsed input data
+ */
+export declare function validateToolInput<Type = unknown>(toolName: string, input: unknown): Type;
+/**
+ * Safely validate tool input without throwing errors.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns Object with success flag and either parsed data or error message
+ */
+export declare function safeValidateToolInput(toolName: string, input: unknown): {
+    /**
+     * Indicates validation succeeded
+     */
+    success: true;
+    /**
+     * The validated and parsed input data
+     */
+    data: unknown;
+} | {
+    /**
+     * Indicates validation failed
+     */
+    success: false;
+    /**
+     * Error message describing validation failure
+     */
+    error: string;
+};
+/**
+ * Get all available tool base names (without mm_ prefix).
+ *
+ * @returns Array of tool base names
+ */
+export declare function getToolNames(): string[];
+/**
+ * Get all available tool names with mm_ prefix.
+ *
+ * @returns Array of prefixed tool names
+ */
+export declare function getPrefixedToolNames(): string[];
+/**
+ * Build a record mapping prefixed tool names to their handler functions.
+ *
+ * @returns Record of tool name to handler function mappings
+ */
+export declare function buildToolHandlersRecord(): Record<string, ToolHandler>;
+export type { ToolEntry };
+//# sourceMappingURL=definitions.d.mts.map

package/dist/mcp-server/tools/definitions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.mts","sourceRoot":"","sources":["../../../src/mcp-server/tools/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY;AAiCnC,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAmB;AA0C9C,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAEF,KAAK,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAEhF,KAAK,SAAS,GAAG;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AAwYF;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,cAAc,EAAE,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAUpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAG,OAAO,EAC9C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,IAAI,CASN;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GAEZ;IACE;;OAEG;IACH,OAAO,EAAE,IAAI,CAAC;IACd;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;CACf,GACD;IACE;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC;IACf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf,CAiBJ;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAMrE;AAED,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/mcp-server/tools/definitions.mjs

@@ -0,0 +1,451 @@
+import { buildInputSchema, launchInputSchema, cleanupInputSchema, getStateInputSchema, navigateInputSchema, waitForNotificationInputSchema, switchToTabInputSchema, closeTabInputSchema, listTestIdsInputSchema, accessibilitySnapshotInputSchema, describeScreenInputSchema, screenshotInputSchema, clickInputSchema, typeInputSchema, waitForInputSchema, knowledgeLastInputSchema, knowledgeSearchInputSchema, knowledgeSummarizeInputSchema, knowledgeSessionsInputSchema, seedContractInputSchema, seedContractsInputSchema, getContractAddressInputSchema, listDeployedContractsInputSchema, runStepsInputSchema, setContextInputSchema, getContextInputSchema, clipboardInputSchema } from "../schemas.mjs";
+import { getSessionManager } from "../session-manager.mjs";
+import { handleRunSteps } from "./batch.mjs";
+import { handleBuild } from "./build.mjs";
+import { handleCleanup } from "./cleanup.mjs";
+import { handleClipboard } from "./clipboard.mjs";
+import { handleSetContext, handleGetContext } from "./context.mjs";
+import { handleListTestIds, handleAccessibilitySnapshot, handleDescribeScreen } from "./discovery-tools.mjs";
+import { handleClick, handleType, handleWaitFor } from "./interaction.mjs";
+import { handleKnowledgeLast, handleKnowledgeSearch, handleKnowledgeSummarize, handleKnowledgeSessions } from "./knowledge.mjs";
+import { handleLaunch } from "./launch.mjs";
+import { handleNavigate, handleWaitForNotification, handleSwitchToTab, handleCloseTab } from "./navigation.mjs";
+import { handleScreenshot } from "./screenshot.mjs";
+import { handleSeedContract, handleSeedContracts, handleGetContractAddress, handleListDeployedContracts } from "./seeding.mjs";
+import { handleGetState } from "./state.mjs";
+export const TOOL_PREFIX = 'mm';
+/**
+ * Create a handler for the build tool that injects build capability.
+ *
+ * @returns A tool handler function for building the extension
+ */
+function createBuildHandler() {
+    return async (input, options) => {
+        const sessionManager = getSessionManager();
+        const buildOptions = {
+            ...options,
+            buildCapability: sessionManager.getBuildCapability?.(),
+        };
+        return handleBuild(input, buildOptions);
+    };
+}
+/**
+ * Create a handler for the state tool that injects state snapshot capability.
+ *
+ * @returns A tool handler function for getting extension state
+ */
+function createStateHandler() {
+    return async (_, options) => {
+        const sessionManager = getSessionManager();
+        const stateOptions = {
+            ...options,
+            stateSnapshotCapability: sessionManager.getStateSnapshotCapability?.(),
+        };
+        return handleGetState(stateOptions);
+    };
+}
+/**
+ * Create a handler for the seed contract tool that injects seeding capability.
+ *
+ * @returns A tool handler function for deploying a single contract
+ */
+function createSeedContractHandler() {
+    return async (input, options) => {
+        const sessionManager = getSessionManager();
+        const seedingOptions = {
+            ...options,
+            seedingCapability: sessionManager.getContractSeedingCapability?.(),
+        };
+        return handleSeedContract(input, seedingOptions);
+    };
+}
+/**
+ * Create a handler for the seed contracts tool that injects seeding capability.
+ *
+ * @returns A tool handler function for deploying multiple contracts
+ */
+function createSeedContractsHandler() {
+    return async (input, options) => {
+        const sessionManager = getSessionManager();
+        const seedingOptions = {
+            ...options,
+            seedingCapability: sessionManager.getContractSeedingCapability?.(),
+        };
+        return handleSeedContracts(input, seedingOptions);
+    };
+}
+/**
+ * Create a handler for the get contract address tool that injects seeding capability.
+ *
+ * @returns A tool handler function for retrieving a deployed contract address
+ */
+function createGetContractAddressHandler() {
+    return async (input, options) => {
+        const sessionManager = getSessionManager();
+        const seedingOptions = {
+            ...options,
+            seedingCapability: sessionManager.getContractSeedingCapability?.(),
+        };
+        return handleGetContractAddress(input, seedingOptions);
+    };
+}
+/**
+ * Create a handler for the list contracts tool that injects seeding capability.
+ *
+ * @returns A tool handler function for listing deployed contracts
+ */
+function createListDeployedContractsHandler() {
+    return async (input, options) => {
+        const sessionManager = getSessionManager();
+        const seedingOptions = {
+            ...options,
+            seedingCapability: sessionManager.getContractSeedingCapability?.(),
+        };
+        return handleListDeployedContracts(input, seedingOptions);
+    };
+}
+const tools = {
+    build: {
+        schema: buildInputSchema,
+        description: `Build the extension using yarn build:test. Call before ${TOOL_PREFIX}_launch if extension is not built.`,
+        handler: createBuildHandler(),
+    },
+    launch: {
+        schema: launchInputSchema,
+        description: 'Launch extension in a headed Chrome browser with Playwright. Returns session info and initial state.',
+        handler: handleLaunch,
+    },
+    cleanup: {
+        schema: cleanupInputSchema,
+        description: 'Stop the browser, Anvil, and all services. Always call when done.',
+        handler: handleCleanup,
+    },
+    get_state: {
+        schema: getStateInputSchema,
+        description: 'Get current extension state including screen, URL, balance, network, and account address.',
+        handler: createStateHandler(),
+    },
+    navigate: {
+        schema: navigateInputSchema,
+        description: 'Navigate to a specific screen in the extension.',
+        handler: handleNavigate,
+    },
+    wait_for_notification: {
+        schema: waitForNotificationInputSchema,
+        description: 'Wait for notification popup to appear (e.g., after dapp interaction). Sets the notification page as the active page for subsequent interactions.',
+        handler: handleWaitForNotification,
+    },
+    switch_to_tab: {
+        schema: switchToTabInputSchema,
+        description: `Switch the active page to a different tracked tab. Use this to direct ${TOOL_PREFIX}_click, ${TOOL_PREFIX}_type, and other interaction tools to a specific page.`,
+        handler: handleSwitchToTab,
+    },
+    close_tab: {
+        schema: closeTabInputSchema,
+        description: 'Close a specific tab by role or URL. Cannot close the extension home page. If closing the active tab, automatically switches to extension home.',
+        handler: handleCloseTab,
+    },
+    list_testids: {
+        schema: listTestIdsInputSchema,
+        description: 'List all visible data-testid attributes on the current page. Use to discover available interaction targets.',
+        handler: handleListTestIds,
+    },
+    accessibility_snapshot: {
+        schema: accessibilitySnapshotInputSchema,
+        description: `Get trimmed accessibility tree with deterministic refs (e1, e2, ...). Use refs with ${TOOL_PREFIX}_click/${TOOL_PREFIX}_type.`,
+        handler: handleAccessibilitySnapshot,
+    },
+    describe_screen: {
+        schema: describeScreenInputSchema,
+        description: 'Get comprehensive screen state: extension state + testIds + accessibility snapshot. Optional screenshot.',
+        handler: handleDescribeScreen,
+    },
+    screenshot: {
+        schema: screenshotInputSchema,
+        description: 'Take a screenshot and save to test-artifacts/screenshots/',
+        handler: handleScreenshot,
+    },
+    click: {
+        schema: clickInputSchema,
+        description: 'Click an element. Specify exactly one of: a11yRef, testId, or selector.',
+        handler: handleClick,
+    },
+    type: {
+        schema: typeInputSchema,
+        description: 'Type text into an element. Specify exactly one of: a11yRef, testId, or selector.',
+        handler: handleType,
+    },
+    wait_for: {
+        schema: waitForInputSchema,
+        description: 'Wait for an element to become visible. Specify exactly one of: a11yRef, testId, or selector.',
+        handler: handleWaitFor,
+    },
+    knowledge_last: {
+        schema: knowledgeLastInputSchema,
+        description: 'Get the last N step records from the knowledge store for the current session.',
+        handler: handleKnowledgeLast,
+    },
+    knowledge_search: {
+        schema: knowledgeSearchInputSchema,
+        description: 'Search step records by tool name, screen, testId, or accessibility names. Default searches all sessions.',
+        handler: handleKnowledgeSearch,
+    },
+    knowledge_summarize: {
+        schema: knowledgeSummarizeInputSchema,
+        description: 'Generate a recipe-like summary of steps taken in a session.',
+        handler: handleKnowledgeSummarize,
+    },
+    knowledge_sessions: {
+        schema: knowledgeSessionsInputSchema,
+        description: 'List recent sessions with metadata for cross-session knowledge retrieval.',
+        handler: handleKnowledgeSessions,
+    },
+    seed_contract: {
+        schema: seedContractInputSchema,
+        description: 'Deploy a smart contract to the local Anvil node. Available: hst (ERC20 TST token), nfts (ERC721), erc1155, piggybank, failing (reverts), multisig, entrypoint (ERC-4337), simpleAccountFactory, verifyingPaymaster.',
+        handler: createSeedContractHandler(),
+    },
+    seed_contracts: {
+        schema: seedContractsInputSchema,
+        description: 'Deploy multiple smart contracts in sequence.',
+        handler: createSeedContractsHandler(),
+    },
+    get_contract_address: {
+        schema: getContractAddressInputSchema,
+        description: 'Get the deployed address of a smart contract.',
+        handler: createGetContractAddressHandler(),
+    },
+    list_contracts: {
+        schema: listDeployedContractsInputSchema,
+        description: 'List all smart contracts deployed in this session.',
+        handler: createListDeployedContractsHandler(),
+    },
+    run_steps: {
+        schema: runStepsInputSchema,
+        description: 'Execute multiple tools in sequence. Reduces round trips for multi-step flows.',
+        handler: handleRunSteps,
+    },
+    set_context: {
+        schema: setContextInputSchema,
+        description: 'Switch workflow context (e2e or prod). Cannot switch during active session.',
+        handler: handleSetContext,
+    },
+    get_context: {
+        schema: getContextInputSchema,
+        description: 'Get current context, available capabilities, and whether context can be switched.',
+        handler: handleGetContext,
+    },
+    clipboard: {
+        schema: clipboardInputSchema,
+        description: "Write text to or read text from the browser clipboard. Use action='write' with text parameter to write, or action='read' to read current clipboard content. Useful for pasting SRP or other data into components that have paste handlers.",
+        handler: handleClipboard,
+    },
+};
+/**
+ * Zod v4's toJSONSchema() marks properties with defaults as required.
+ * This is incorrect for MCP tool input schemas where LLM clients shouldn't
+ * be required to provide values that have defaults. This function recursively
+ * removes those properties from the required array.
+ *
+ * @param schema The JSON schema to process
+ * @returns The modified schema with defaults removed from required array
+ */
+function removeDefaultsFromRequired(schema) {
+    const result = { ...schema };
+    if (Array.isArray(result.allOf)) {
+        result.allOf = result.allOf.map((item) => removeDefaultsFromRequired(item));
+    }
+    if (Array.isArray(result.anyOf)) {
+        result.anyOf = result.anyOf.map((item) => removeDefaultsFromRequired(item));
+    }
+    if (Array.isArray(result.oneOf)) {
+        result.oneOf = result.oneOf.map((item) => removeDefaultsFromRequired(item));
+    }
+    if (result.properties &&
+        typeof result.properties === 'object' &&
+        result.properties !== null) {
+        const newProperties = {};
+        for (const [key, value] of Object.entries(result.properties)) {
+            if (value && typeof value === 'object') {
+                newProperties[key] = removeDefaultsFromRequired(value);
+            }
+            else {
+                newProperties[key] = value;
+            }
+        }
+        result.properties = newProperties;
+    }
+    if (Array.isArray(result.required) &&
+        result.properties &&
+        typeof result.properties === 'object') {
+        const properties = result.properties;
+        result.required = result.required.filter((propName) => {
+            const prop = properties[propName];
+            return prop && !('default' in prop);
+        });
+        if (result.required.length === 0) {
+            delete result.required;
+        }
+    }
+    return result;
+}
+/**
+ * MCP protocol doesn't support allOf/oneOf/anyOf at the top level of input schemas.
+ * This flattens allOf into a single merged object schema.
+ *
+ * @param schema The JSON schema to flatten
+ * @returns The flattened schema with allOf merged into properties
+ */
+function flattenTopLevelAllOf(schema) {
+    if (!Array.isArray(schema.allOf)) {
+        return schema;
+    }
+    const mergedProperties = {};
+    const mergedRequired = [];
+    for (const subSchema of schema.allOf) {
+        if (subSchema.properties && typeof subSchema.properties === 'object') {
+            Object.assign(mergedProperties, subSchema.properties);
+        }
+        if (Array.isArray(subSchema.required)) {
+            mergedRequired.push(...subSchema.required);
+        }
+    }
+    const result = {
+        type: 'object',
+        properties: mergedProperties,
+        additionalProperties: false,
+    };
+    if (mergedRequired.length > 0) {
+        result.required = [...new Set(mergedRequired)];
+    }
+    return result;
+}
+/**
+ * Convert a Zod schema to a JSON schema suitable for MCP tool definitions.
+ *
+ * @param schema The Zod schema to convert
+ * @returns The converted JSON schema with defaults removed and allOf flattened
+ */
+function zodSchemaToJsonSchema(schema) {
+    const jsonSchema = schema.toJSONSchema();
+    const { $schema: _, ...rest } = jsonSchema;
+    const flattened = flattenTopLevelAllOf(rest);
+    if (flattened.type === 'object' && !('additionalProperties' in flattened)) {
+        flattened.additionalProperties = false;
+    }
+    return removeDefaultsFromRequired(flattened);
+}
+/**
+ * Get all tool definitions with their schemas and descriptions.
+ *
+ * @returns Array of tool definitions for all available MCP tools
+ */
+export function getToolDefinitions() {
+    return Object.entries(tools).map(([baseName, tool]) => ({
+        name: `${TOOL_PREFIX}_${baseName}`,
+        description: tool.description,
+        inputSchema: zodSchemaToJsonSchema(tool.schema),
+    }));
+}
+/**
+ * Get the handler function for a specific tool by name.
+ *
+ * @param name The tool name (with or without mm_ prefix)
+ * @returns The tool handler function or undefined if tool not found
+ */
+export function getToolHandler(name) {
+    const prefixedMatch = Object.entries(tools).find(([baseName]) => `${TOOL_PREFIX}_${baseName}` === name);
+    if (prefixedMatch) {
+        return prefixedMatch[1].handler;
+    }
+    const tool = tools[name];
+    return tool?.handler;
+}
+/**
+ * Check if a tool handler exists for the given tool name.
+ *
+ * @param name The tool name to check
+ * @returns True if a handler exists for the tool, false otherwise
+ */
+export function hasToolHandler(name) {
+    return getToolHandler(name) !== undefined;
+}
+/**
+ * Extract the base name from a tool name by removing the mm_ prefix.
+ *
+ * @param toolName The tool name (with or without mm_ prefix)
+ * @returns The base name without the prefix
+ */
+export function extractBaseName(toolName) {
+    const prefixWithUnderscore = `${TOOL_PREFIX}_`;
+    if (toolName.startsWith(prefixWithUnderscore)) {
+        return toolName.slice(prefixWithUnderscore.length);
+    }
+    return toolName;
+}
+/**
+ * Validate tool input against the tool's schema and return parsed data.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns The validated and parsed input data
+ */
+export function validateToolInput(toolName, input) {
+    const baseName = extractBaseName(toolName);
+    const tool = tools[baseName];
+    if (!tool) {
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+    return tool.schema.parse(input ?? {});
+}
+/**
+ * Safely validate tool input without throwing errors.
+ *
+ * @param toolName The tool name to validate input for
+ * @param input The input data to validate
+ * @returns Object with success flag and either parsed data or error message
+ */
+export function safeValidateToolInput(toolName, input) {
+    const baseName = extractBaseName(toolName);
+    const tool = tools[baseName];
+    if (!tool) {
+        return { success: false, error: `Unknown tool: ${toolName}` };
+    }
+    const result = tool.schema.safeParse(input ?? {});
+    if (!result.success) {
+        const errorMessage = result.error.issues
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join('; ');
+        return { success: false, error: errorMessage };
+    }
+    return { success: true, data: result.data };
+}
+/**
+ * Get all available tool base names (without mm_ prefix).
+ *
+ * @returns Array of tool base names
+ */
+export function getToolNames() {
+    return Object.keys(tools);
+}
+/**
+ * Get all available tool names with mm_ prefix.
+ *
+ * @returns Array of prefixed tool names
+ */
+export function getPrefixedToolNames() {
+    return Object.keys(tools).map((name) => `${TOOL_PREFIX}_${name}`);
+}
+/**
+ * Build a record mapping prefixed tool names to their handler functions.
+ *
+ * @returns Record of tool name to handler function mappings
+ */
+export function buildToolHandlersRecord() {
+    const handlers = {};
+    for (const [baseName, tool] of Object.entries(tools)) {
+        handlers[`${TOOL_PREFIX}_${baseName}`] = tool.handler;
+    }
+    return handlers;
+}
+//# sourceMappingURL=definitions.mjs.map