it-tools-mcp 3.2.10 → 3.6.0

package/build/tools/crypto/jwt-decode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerJwtDecode(server) {
-    server.tool("jwt-decode", "Decode JWT token (header and payload only)", {
-        token: z.string().describe("JWT token to decode"),
+    server.registerTool("jwt-decode", {
+        description: "Decode JWT token (header and payload only)",
+        inputSchema: {
+            token: z.string().describe("JWT token to decode"),
+        }
     }, async ({ token }) => {
         try {
             const parts = token.split('.');

package/build/tools/crypto/otp-code-generator/index.js

@@ -1,10 +1,13 @@
 import speakeasy from "speakeasy";
 import { z } from "zod";
 export function registerOtpCodeGenerator(server) {
-    server.tool("otp-code-generator", "Generate Time-based One-Time Password (TOTP) codes", {
-        secret: z.string().describe("Base32 encoded secret key"),
-        digits: z.number().describe("Number of digits in the code").optional(),
-        period: z.number().describe("Time period in seconds").optional(),
+    server.registerTool("otp-code-generator", {
+        description: "Generate Time-based One-Time Password (TOTP) codes",
+        inputSchema: {
+            secret: z.string().describe("Base32 encoded secret key"),
+            digits: z.number().describe("Number of digits in the code").optional(),
+            period: z.number().describe("Time period in seconds").optional(),
+        }
     }, async ({ secret, digits = 6, period = 30 }) => {
         try {
             if (digits < 4 || digits > 10) {

package/build/tools/crypto/password-generate/index.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
 export function registerPasswordGenerate(server) {
-    server.tool("password-generate", "Generate a secure password", {
-        length: z.number().describe("Password length").optional(),
-        includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
-        includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
-        includeNumbers: z.boolean().describe("Include numbers").optional(),
-        includeSymbols: z.boolean().describe("Include symbols").optional(),
+    server.registerTool("password-generate", {
+        description: "Generate a secure password",
+        inputSchema: {
+            length: z.number().describe("Password length").optional(),
+            includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
+            includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
+            includeNumbers: z.boolean().describe("Include numbers").optional(),
+            includeSymbols: z.boolean().describe("Include symbols").optional(),
+        }
     }, async ({ length = 16, includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = true }) => {
         if (length < 4 || length > 128) {
             return {

package/build/tools/crypto/token-generator/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerTokenGenerator(server) {
-    server.tool("token-generator", "Generate secure random tokens", {
-        length: z.number().describe("Token length").optional(),
-        charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
-        customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+    server.registerTool("token-generator", {
+        description: "Generate secure random tokens",
+        inputSchema: {
+            length: z.number().describe("Token length").optional(),
+            charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
+            customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+        }
     }, async ({ length = 32, charset = "alphanumeric", customChars }) => {
         try {
             if (length < 8 || length > 256) {

package/build/tools/dataFormat/html-to-markdown/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerHtmlToMarkdown(server) {
-    server.tool("html-to-markdown", "Convert HTML to Markdown", {
-        html: z.string().describe("HTML content to convert to Markdown"),
+    server.registerTool("html-to-markdown", {
+        description: "Convert HTML to Markdown",
+        inputSchema: {
+            html: z.string().describe("HTML content to convert to Markdown"),
+        }
     }, async ({ html }) => {
         try {
             const TurndownService = (await import("turndown")).default;

package/build/tools/dataFormat/json-diff/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonDiff(server) {
-    server.tool("json-diff", "Compare two JSON objects and show differences", {
-        json1: z.string().describe("First JSON object"),
-        json2: z.string().describe("Second JSON object"),
+    server.registerTool("json-diff", {
+        description: "Compare two JSON objects and show differences",
+        inputSchema: {
+            json1: z.string().describe("First JSON object"),
+            json2: z.string().describe("Second JSON object"),
+        }
     }, async ({ json1, json2 }) => {
         try {
             const obj1 = JSON.parse(json1);

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

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonFormat(server) {
-    server.tool("json-format", "Format and validate JSON", {
-        json: z.string().describe("JSON string to format"),
-        indent: z.number().describe("Number of spaces for indentation").optional(),
+    server.registerTool("json-format", {
+        description: 'Format and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON',
+        inputSchema: {
+            json: z.string().describe("JSON string to format"),
+            indent: z.number().describe("Number of spaces for indentation").optional(),
+        }
     }, async ({ json, indent = 2 }) => {
         try {
             if (indent < 0 || indent > 10) {
@@ -88,6 +91,7 @@ Examples of supported formats:
         }
         catch (error) {
             return {
+                isError: true,
                 content: [
                     {
                         type: "text",

package/build/tools/dataFormat/json-minify/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerJsonMinify(server) {
-    server.tool("json-minify", "Minify JSON by removing whitespace", {
-        json: z.string().describe("JSON string to minify"),
+    server.registerTool("json-minify", {
+        description: "Minify JSON by removing whitespace",
+        inputSchema: {
+            json: z.string().describe("JSON string to minify"),
+        }
     }, async ({ json }) => {
         try {
             const parsed = JSON.parse(json);

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

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonToCsv(server) {
-    server.tool("json-to-csv", "Convert JSON to CSV format", {
-        json: z.string().describe("JSON string to convert to CSV"),
-        delimiter: z.string().describe("CSV delimiter").optional(),
+    server.registerTool("json-to-csv", {
+        description: "Convert JSON to CSV format",
+        inputSchema: {
+            json: z.string().describe("JSON string to convert to CSV"),
+            delimiter: z.string().describe("CSV delimiter").optional(),
+        }
     }, async ({ json, delimiter = "," }) => {
         try {
             const Papa = (await import("papaparse")).default;

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

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

package/build/tools/dataFormat/markdown-to-html/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerMarkdownToHtml(server) {
-    server.tool("markdown-to-html", "Convert Markdown to HTML", {
-        markdown: z.string().describe("Markdown content to convert to HTML"),
+    server.registerTool("markdown-to-html", {
+        description: "Convert Markdown to HTML",
+        inputSchema: {
+            markdown: z.string().describe("Markdown content to convert to HTML"),
+        }
     }, async ({ markdown }) => {
         try {
             const { marked } = await import("marked");

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

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerPhoneFormat(server) {
-    server.tool("phone-format", "Parse and format phone numbers", {
-        phoneNumber: z.string().describe("Phone number to parse and format"),
-        countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+    server.registerTool("phone-format", {
+        description: "Parse and format phone numbers",
+        inputSchema: {
+            phoneNumber: z.string().describe("Phone number to parse and format"),
+            countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+        }
     }, async ({ phoneNumber, countryCode }) => {
         try {
             const { isValidPhoneNumber, parsePhoneNumber } = await import("libphonenumber-js");

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 {