it-tools-mcp 3.2.12 → 3.6.0

package/build/tools/dataFormat/sql-format/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerSqlFormat(server) {
-    server.tool("sql-format", "Format and prettify SQL queries", {
-        sql: z.string().describe("SQL query to format"),
-        dialect: z.string().optional().describe("SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."),
+    server.registerTool("sql-format", {
+        description: "Format and prettify SQL queries",
+        inputSchema: {
+            sql: z.string().describe("SQL query to format"),
+            dialect: z.string().optional().describe("SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."),
+        }
     }, async ({ sql, dialect = "sql" }) => {
         try {
             const { format: formatSQL } = await import("sql-formatter");

package/build/tools/dataFormat/toml-to-json/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTomlToJson(server) {
-    server.tool("toml-to-json", "Convert TOML to JSON format", {
-        toml: z.string().describe("TOML string to convert"),
+    server.registerTool("toml-to-json", {
+        description: "Convert TOML to JSON format",
+        inputSchema: {
+            toml: z.string().describe("TOML string to convert"),
+        }
     }, async ({ toml: tomlString }) => {
         try {
             const toml = await import("@iarna/toml");

package/build/tools/dataFormat/xml-format/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerXmlFormat(server) {
-    server.tool("xml-format", "Format and prettify XML", {
-        xml: z.string().describe("XML string to format"),
-        indent: z.number().describe("Number of spaces for indentation").optional(),
+    server.registerTool("xml-format", {
+        description: "Format and prettify XML",
+        inputSchema: {
+            xml: z.string().describe("XML string to format"),
+            indent: z.number().describe("Number of spaces for indentation").optional(),
+        }
     }, async ({ xml, indent = 2 }) => {
         try {
             const formatXML = (await import("xml-formatter")).default;

package/build/tools/dataFormat/yaml-format/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerYamlFormat(server) {
-    server.tool("yaml-format", "Format and prettify YAML", {
-        yaml: z.string().describe("YAML string to format"),
+    server.registerTool("yaml-format", {
+        description: "Format and prettify YAML",
+        inputSchema: {
+            yaml: z.string().describe("YAML string to format"),
+        }
     }, async ({ yaml }) => {
         try {
             const YAML = await import("js-yaml");

package/build/tools/development/crontab-generate/index.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 import { CronExpressionParser } from 'cron-parser';
 export function registerCrontabGenerate(server) {
-    server.tool("crontab-generate", "Generate crontab expressions", {
-        minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
-        hour: z.string().describe("Hour (0-23, *, */n, n-m)").optional(),
-        dayOfMonth: z.string().describe("Day of month (1-31, *, */n, n-m)").optional(),
-        month: z.string().describe("Month (1-12, *, */n, n-m)").optional(),
-        dayOfWeek: z.string().describe("Day of week (0-7, *, */n, n-m)").optional(),
+    server.registerTool("crontab-generate", {
+        description: "Generate crontab expressions",
+        inputSchema: {
+            minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
+            hour: z.string().describe("Hour (0-23, *, */n, n-m)").optional(),
+            dayOfMonth: z.string().describe("Day of month (1-31, *, */n, n-m)").optional(),
+            month: z.string().describe("Month (1-12, *, */n, n-m)").optional(),
+            dayOfWeek: z.string().describe("Day of week (0-7, *, */n, n-m)").optional(),
+        }
     }, async ({ minute = "*", hour = "*", dayOfMonth = "*", month = "*", dayOfWeek = "*" }) => {
         try {
             const cronExpression = `${minute} ${hour} ${dayOfMonth} ${month} ${dayOfWeek}`;

package/build/tools/development/html-prettifier/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerHtmlPrettifier(server) {
-    server.tool("html-prettifier", "Format and beautify HTML code", {
-        html: z.string().describe("HTML code to prettify"),
-        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+    server.registerTool("html-prettifier", {
+        description: "Format and beautify HTML code",
+        inputSchema: {
+            html: z.string().describe("HTML code to prettify"),
+            indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+        }
     }, async ({ html, indentSize }) => {
         try {
             // Simple HTML prettifier

package/build/tools/development/javascript-prettifier/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerJavascriptPrettifier(server) {
-    server.tool("javascript-prettifier", "Format and beautify JavaScript/CSS code", {
-        code: z.string().describe("JavaScript or CSS code to prettify"),
-        type: z.enum(["javascript", "css"]).describe("Type of code to format"),
-        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+    server.registerTool("javascript-prettifier", {
+        description: "Format and beautify JavaScript/CSS code",
+        inputSchema: {
+            code: z.string().describe("JavaScript or CSS code to prettify"),
+            type: z.enum(["javascript", "css"]).describe("Type of code to format"),
+            indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+        }
     }, async ({ code, type, indentSize }) => {
         try {
             let formatted = code;

package/build/tools/development/list-converter/index.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
 export function registerListConverter(server) {
-    server.tool("list-converter", "Convert between different list formats (comma-separated, line-separated, etc.)", {
-        list: z.string().describe("Input list to convert"),
-        inputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe"]).describe("Input format"),
-        outputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe", "json", "quoted"]).describe("Output format"),
-        trim: z.boolean().describe("Trim whitespace from items").optional(),
+    server.registerTool("list-converter", {
+        description: "Convert between different list formats (comma-separated, line-separated, etc.)",
+        inputSchema: {
+            list: z.string().describe("Input list to convert"),
+            inputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe"]).describe("Input format"),
+            outputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe", "json", "quoted"]).describe("Output format"),
+            trim: z.boolean().describe("Trim whitespace from items").optional(),
+        }
     }, async ({ list, inputFormat, outputFormat, trim = true }) => {
         try {
             const separators = {

package/build/tools/development/markdown-toc-generator/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerMarkdownTocGenerator(server) {
-    server.tool("markdown-toc-generator", "Generate a table of contents from Markdown headers", {
-        markdown: z.string().describe("Markdown content to generate TOC from"),
-        maxLevel: z.number().optional().default(6).describe("Maximum header level to include (1-6)"),
-        generateAnchors: z.boolean().optional().default(true).describe("Whether to generate anchor links")
+    server.registerTool("markdown-toc-generator", {
+        description: "Generate a table of contents from Markdown headers",
+        inputSchema: {
+            markdown: z.string().describe("Markdown content to generate TOC from"),
+            maxLevel: z.number().optional().default(6).describe("Maximum header level to include (1-6)"),
+            generateAnchors: z.boolean().optional().default(true).describe("Whether to generate anchor links")
+        }
     }, async ({ markdown, maxLevel, generateAnchors }) => {
         // Extract headers from markdown
         const headerRegex = /^(#{1,6})\s+(.+)$/gm;

package/build/tools/development/regex-tester/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerRegexTester(server) {
-    server.tool("regex-tester", "Test regular expressions against text", {
-        pattern: z.string().describe("Regular expression pattern"),
-        text: z.string().describe("Text to test against the regex"),
-        flags: z.string().optional().describe("Regex flags (g, i, m, s, u, y)"),
+    server.registerTool("regex-tester", {
+        description: "Test regular expressions against text",
+        inputSchema: {
+            pattern: z.string().describe("Regular expression pattern"),
+            text: z.string().describe("Text to test against the regex"),
+            flags: z.string().optional().describe("Regex flags (g, i, m, s, u, y)"),
+        }
     }, async ({ pattern, text, flags }) => {
         try {
             const regex = new RegExp(pattern, flags);

package/build/tools/docker/docker-compose-to-docker-run/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerComposeToRun(server) {
-    server.tool("docker-compose-to-docker-run", "Convert Docker Compose files to docker run commands", {
-        content: z.string().describe("Docker Compose file content to convert"),
+    server.registerTool("docker-compose-to-docker-run", {
+        description: "Convert Docker Compose files to docker run commands",
+        inputSchema: {
+            content: z.string().describe("Docker Compose file content to convert"),
+        }
     }, async ({ content }) => {
         if (!content?.trim()) {
             return {

package/build/tools/docker/docker-compose-validator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerComposeValidator(server) {
-    server.tool("docker-compose-validator", "Validate Docker Compose files for syntax and compatibility", {
-        content: z.string().describe("Docker Compose file content to validate"),
+    server.registerTool("docker-compose-validator", {
+        description: "Validate Docker Compose files for syntax and compatibility",
+        inputSchema: {
+            content: z.string().describe("Docker Compose file content to validate"),
+        }
     }, async ({ content }) => {
         if (!content?.trim()) {
             return {

package/build/tools/docker/docker-reference/index.js

@@ -1,5 +1,8 @@
 export function registerDockerReference(server) {
-    server.tool("docker-reference", "Get Docker commands reference and cheatsheet", {}, async () => {
+    server.registerTool("docker-reference", {
+        description: "Get Docker commands reference and cheatsheet",
+        inputSchema: {}
+    }, async () => {
         const reference = `# Docker Quick Reference
 
 ## Installation & Setup

package/build/tools/docker/docker-run-to-docker-compose/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerRunToCompose(server) {
-    server.tool("docker-run-to-docker-compose", "Convert docker run commands to Docker Compose format", {
-        commands: z.string().describe("Docker run commands to convert (one per line)"),
+    server.registerTool("docker-run-to-docker-compose", {
+        description: "Convert docker run commands to Docker Compose format",
+        inputSchema: {
+            commands: z.string().describe("Docker run commands to convert (one per line)"),
+        }
     }, async ({ commands }) => {
         if (!commands?.trim()) {
             return {

package/build/tools/docker/traefik-compose-generator/index.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerTraefikComposeGenerator(server) {
-    server.tool("traefik-compose-generator", "Generate Traefik Docker Compose configuration", {
-        domain: z.string().optional().describe("Domain for Traefik services (default: example.com)"),
-        email: z.string().optional().describe("Email for Let's Encrypt (default: admin@example.com)"),
-        network: z.string().optional().describe("Docker network name (default: traefik)"),
-        serviceName: z.string().optional().describe("Example service name (default: webapp)"),
-        serviceImage: z.string().optional().describe("Example service image (default: nginx:latest)"),
+    server.registerTool("traefik-compose-generator", {
+        description: "Generate Traefik Docker Compose configuration",
+        inputSchema: {
+            domain: z.string().optional().describe("Domain for Traefik services (default: example.com)"),
+            email: z.string().optional().describe("Email for Let's Encrypt (default: admin@example.com)"),
+            network: z.string().optional().describe("Docker network name (default: traefik)"),
+            serviceName: z.string().optional().describe("Example service name (default: webapp)"),
+            serviceImage: z.string().optional().describe("Example service image (default: nginx:latest)"),
+        }
     }, async ({ domain = 'example.com', email = 'admin@example.com', network = 'traefik', serviceName = 'webapp', serviceImage = 'nginx:latest' }) => {
         try {
             const compose = {

package/build/tools/encoding/base64-decode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerBase64Decode(server) {
-    server.tool("base64-decode", "Decode Base64 text", {
-        text: z.string().describe("Base64 text to decode"),
+    server.registerTool("base64-decode", {
+        description: 'Decode Base64 text back to original text. Example: "SGVsbG8gV29ybGQ=" → "Hello World"',
+        inputSchema: {
+            text: z.string().min(1).regex(/^[A-Za-z0-9+/]*={0,2}$/, "Invalid Base64 format").describe("Base64 text to decode"),
+        }
     }, async ({ text }) => {
         try {
             const decoded = Buffer.from(text, 'base64').toString('utf-8');
@@ -16,6 +19,7 @@ export function registerBase64Decode(server) {
         }
         catch (error) {
             return {
+                isError: true,
                 content: [
                     {
                         type: "text",

package/build/tools/encoding/base64-encode/index.js

@@ -1,16 +1,32 @@
 import { z } from "zod";
 export function registerBase64Encode(server) {
-    server.tool("base64-encode", "Encode text to Base64", {
-        text: z.string().describe("Text to encode to Base64"),
+    server.registerTool("base64-encode", {
+        description: 'Encode text to Base64 format. Example: "Hello World" → "SGVsbG8gV29ybGQ="',
+        inputSchema: {
+            text: z.string().min(1).describe("Text to encode to Base64"),
+        }
     }, async ({ text }) => {
-        const encoded = Buffer.from(text, 'utf-8').toString('base64');
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Base64 encoded: ${encoded}`,
-                },
-            ],
-        };
+        try {
+            const encoded = Buffer.from(text, 'utf-8').toString('base64');
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Base64 encoded: ${encoded}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Error encoding to Base64: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
     });
 }

package/build/tools/encoding/html-decode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerHtmlDecode(server) {
-    server.tool("html-decode", "Decode HTML entities", {
-        text: z.string().describe("HTML encoded text to decode"),
+    server.registerTool("html-decode", {
+        description: "Decode HTML entities",
+        inputSchema: {
+            text: z.string().describe("HTML encoded text to decode"),
+        }
     }, async ({ text }) => {
         const decoded = text
             .replace(/&/g, '&')

package/build/tools/encoding/html-encode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerHtmlEncode(server) {
-    server.tool("html-encode", "Encode HTML entities", {
-        text: z.string().describe("Text to HTML encode"),
+    server.registerTool("html-encode", {
+        description: "Encode HTML entities",
+        inputSchema: {
+            text: z.string().describe("Text to HTML encode"),
+        }
     }, async ({ text }) => {
         const encoded = text
             .replace(/&/g, '&')

package/build/tools/encoding/html-entities-extended/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerHtmlEntitiesExtended(server) {
-    server.tool("html-entities-extended", "Extended HTML entity encoding/decoding", {
-        text: z.string().describe("Text to encode or decode"),
-        operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+    server.registerTool("html-entities-extended", {
+        description: "Extended HTML entity encoding/decoding",
+        inputSchema: {
+            text: z.string().describe("Text to encode or decode"),
+            operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+        }
     }, async ({ text, operation }) => {
         try {
             if (operation === "encode") {

package/build/tools/encoding/text-to-binary/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerTextToBinary(server) {
-    server.tool("text-to-binary", "Convert text to binary and vice versa", {
-        input: z.string().describe("Text to convert to binary, or binary to convert to text"),
-        operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+    server.registerTool("text-to-binary", {
+        description: "Convert text to binary and vice versa",
+        inputSchema: {
+            input: z.string().describe("Text to convert to binary, or binary to convert to text"),
+            operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+        }
     }, async ({ input, operation }) => {
         try {
             if (operation === "encode") {

package/build/tools/encoding/url-decode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerUrlDecode(server) {
-    server.tool("url-decode", "URL decode text", {
-        text: z.string().describe("URL encoded text to decode"),
+    server.registerTool("url-decode", {
+        description: "URL decode text",
+        inputSchema: {
+            text: z.string().describe("URL encoded text to decode"),
+        }
     }, async ({ text }) => {
         try {
             const decoded = decodeURIComponent(text);

package/build/tools/encoding/url-encode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerUrlEncode(server) {
-    server.tool("url-encode", "URL encode text", {
-        text: z.string().describe("Text to URL encode"),
+    server.registerTool("url-encode", {
+        description: "URL encode text",
+        inputSchema: {
+            text: z.string().describe("Text to URL encode"),
+        }
     }, async ({ text }) => {
         const encoded = encodeURIComponent(text);
         return {

package/build/tools/forensic/file-type-identifier/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import { Buffer } from 'buffer';
 export function registerFileTypeIdentifier(server) {
-    server.tool("file-type-identifier", "Identify file type based on magic numbers/file signatures", {
-        data: z.string().describe("Hex data or base64 data of file header"),
-        format: z.enum(["hex", "base64"]).describe("Format of the input data")
+    server.registerTool("file-type-identifier", {
+        description: "Identify file type based on magic numbers/file signatures",
+        inputSchema: {
+            data: z.string().describe("Hex data or base64 data of file header"),
+            format: z.enum(["hex", "base64"]).describe("Format of the input data")
+        }
     }, async ({ data, format }) => {
         try {
             let buffer;

package/build/tools/forensic/safelink-decoder/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerSafelinkDecoder(server) {
-    server.tool("safelink-decoder", "Decode Microsoft Outlook SafeLink URLs", {
-        safelink: z.string().describe("SafeLink URL to decode")
+    server.registerTool("safelink-decoder", {
+        description: "Decode Microsoft Outlook SafeLink URLs",
+        inputSchema: {
+            safelink: z.string().describe("SafeLink URL to decode")
+        }
     }, async ({ safelink }) => {
         try {
             const url = new URL(safelink);

package/build/tools/forensic/url-fanger/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerUrlFanger(server) {
-    server.tool("url-fanger", "Defang or refang URLs for safe sharing (security analysis)", {
-        text: z.string().describe("Text containing URLs to fang/defang"),
-        operation: z.enum(["defang", "refang"]).describe("Whether to defang (make safe) or refang (restore) URLs")
+    server.registerTool("url-fanger", {
+        description: "Defang or refang URLs for safe sharing (security analysis)",
+        inputSchema: {
+            text: z.string().describe("Text containing URLs to fang/defang"),
+            operation: z.enum(["defang", "refang"]).describe("Whether to defang (make safe) or refang (restore) URLs")
+        }
     }, async ({ text, operation }) => {
         try {
             let result = text;

package/build/tools/idGenerators/qr-generate/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerQrGenerate(server) {
-    server.tool("qr-generate", "Generate QR code for any text including URLs, WiFi networks, contact info, etc.", {
-        text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
-        size: z.number().describe("Size multiplier (1-3)").optional(),
+    server.registerTool("qr-generate", {
+        description: "Generate QR code for any text including URLs, WiFi networks, contact info, etc.",
+        inputSchema: {
+            text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
+            size: z.number().describe("Size multiplier (1-3)").optional(),
+        }
     }, async ({ text, size = 1 }) => {
         try {
             const QRCode = (await import("qrcode")).default;

package/build/tools/idGenerators/svg-placeholder-generator/index.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
 export function registerSvgPlaceholderGenerator(server) {
-    server.tool("svg-placeholder-generator", "Generate SVG placeholder images", {
-        width: z.number().describe("Width in pixels").optional(),
-        height: z.number().describe("Height in pixels").optional(),
-        backgroundColor: z.string().describe("Background color (hex)").optional(),
-        textColor: z.string().describe("Text color (hex)").optional(),
-        text: z.string().optional().describe("Custom text (default: dimensions)"),
+    server.registerTool("svg-placeholder-generator", {
+        description: "Generate SVG placeholder images",
+        inputSchema: {
+            width: z.number().describe("Width in pixels").optional(),
+            height: z.number().describe("Height in pixels").optional(),
+            backgroundColor: z.string().describe("Background color (hex)").optional(),
+            textColor: z.string().describe("Text color (hex)").optional(),
+            text: z.string().optional().describe("Custom text (default: dimensions)"),
+        }
     }, async ({ width = 300, height = 200, backgroundColor = "#cccccc", textColor = "#666666", text }) => {
         try {
             if (width < 1 || width > 2000 || height < 1 || height > 2000) {

package/build/tools/idGenerators/ulid-generate/index.js

@@ -1,5 +1,8 @@
 export function registerUlidGenerate(server) {
-    server.tool("ulid-generate", "Generate Universally Unique Lexicographically Sortable Identifier", {}, async () => {
+    server.registerTool("ulid-generate", {
+        description: "Generate Universally Unique Lexicographically Sortable Identifier",
+        inputSchema: {}
+    }, async () => {
         try {
             // Simplified ULID implementation
             const timestamp = Date.now();

package/build/tools/idGenerators/uuid-generate/index.js

@@ -1,6 +1,9 @@
 import { randomUUID } from "crypto";
 export function registerUuidGenerate(server) {
-    server.tool("uuid-generate", "Generate a random UUID v4", {}, async () => {
+    server.registerTool("uuid-generate", {
+        description: 'Generate a universally unique identifier (UUID). Example: generates "550e8400-e29b-41d4-a716-446655440000"',
+        inputSchema: {}
+    }, async () => {
         const uuid = randomUUID();
         return {
             content: [

package/build/tools/math/math-evaluate/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerMathEvaluate(server) {
-    server.tool("math-evaluate", "Safely evaluate mathematical expressions", {
-        expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
+    server.registerTool("math-evaluate", {
+        description: "Safely evaluate mathematical expressions",
+        inputSchema: {
+            expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
+        }
     }, async ({ expression }) => {
         try {
             // @ts-ignore: Ignore missing type declarations for mathjs

package/build/tools/math/number-base-converter/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerNumberBaseConverter(server) {
-    server.tool("number-base-converter", "Convert numbers between different bases (binary, octal, decimal, hexadecimal)", {
-        number: z.string().describe("Number to convert"),
-        fromBase: z.number().describe("Source base (2-36)"),
-        toBase: z.number().describe("Target base (2-36)")
+    server.registerTool("number-base-converter", {
+        description: "Convert numbers between different bases (binary, octal, decimal, hexadecimal)",
+        inputSchema: {
+            number: z.string().describe("Number to convert"),
+            fromBase: z.number().describe("Source base (2-36)"),
+            toBase: z.number().describe("Target base (2-36)")
+        }
     }, async ({ number, fromBase, toBase }) => {
         try {
             if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {

package/build/tools/math/percentage-calculator/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerPercentageCalculator(server) {
-    server.tool("percentage-calculator", "Calculate percentages, percentage of a number, or percentage change", {
-        operation: z.enum(["percentage-of", "what-percentage", "percentage-change"]).describe("Type of percentage calculation"),
-        value1: z.number().describe("First value"),
-        value2: z.number().describe("Second value")
+    server.registerTool("percentage-calculator", {
+        description: "Calculate percentages, percentage of a number, or percentage change",
+        inputSchema: {
+            operation: z.enum(["percentage-of", "what-percentage", "percentage-change"]).describe("Type of percentage calculation"),
+            value1: z.number().describe("First value"),
+            value2: z.number().describe("Second value")
+        }
     }, async ({ operation, value1, value2 }) => {
         try {
             let result;

package/build/tools/math/roman-numeral-converter/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerRomanNumeralConverter(server) {
-    server.tool("roman-numeral-converter", "Convert between Arabic numbers and Roman numerals", {
-        input: z.string().describe("Number to convert (Arabic number 1-3999 or Roman numeral)")
+    server.registerTool("roman-numeral-converter", {
+        description: "Convert between Arabic numbers and Roman numerals",
+        inputSchema: {
+            input: z.string().describe("Number to convert (Arabic number 1-3999 or Roman numeral)")
+        }
     }, async ({ input }) => {
         try {
             // Auto-detect if input is a number or Roman numeral

package/build/tools/math/temperature-converter/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerTemperatureConverter(server) {
-    server.tool("temperature-converter", "Convert temperatures between Celsius, Fahrenheit, and Kelvin", {
-        temperature: z.number().describe("Temperature value to convert"),
-        from: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Source temperature unit"),
-        to: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Target temperature unit")
+    server.registerTool("temperature-converter", {
+        description: "Convert temperatures between Celsius, Fahrenheit, and Kelvin",
+        inputSchema: {
+            temperature: z.number().describe("Temperature value to convert"),
+            from: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Source temperature unit"),
+            to: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Target temperature unit")
+        }
     }, async ({ temperature, from, to }) => {
         try {
             // Convert to Celsius first