it-tools-mcp 3.2.12 → 3.6.0

package/build/tools/math/unix-timestamp-converter/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerUnixTimestampConverter(server) {
-    server.tool("unix-timestamp-converter", "Convert between Unix timestamps and human-readable dates", {
-        input: z.string().describe("Unix timestamp (seconds) or ISO date string")
+    server.registerTool("unix-timestamp-converter", {
+        description: "Convert between Unix timestamps and human-readable dates",
+        inputSchema: {
+            input: z.string().describe("Unix timestamp (seconds) or ISO date string")
+        }
     }, async ({ input }) => {
         try {
             // Auto-detect if input is a timestamp or date string

package/build/tools/network/cat/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerCat(server) {
-    server.tool("cat", "Display content of a file", {
-        file: z.string().describe("File path")
+    server.registerTool("cat", {
+        description: "Display content of a file",
+        inputSchema: {
+            file: z.string().describe("File path")
+        }
     }, async ({ file }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

package/build/tools/network/cidr-to-ip-range/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerCidrToIpRange(server) {
-    server.tool("cidr-to-ip-range", "Convert CIDR notation to IP address range", {
-        cidr: z.string().describe("CIDR notation (e.g., 192.168.1.0/24)")
+    server.registerTool("cidr-to-ip-range", {
+        description: "Convert CIDR notation to IP address range",
+        inputSchema: {
+            cidr: z.string().describe("CIDR notation (e.g., 192.168.1.0/24)")
+        }
     }, async ({ cidr }) => {
         try {
             const [network, prefixLength] = cidr.split('/');

package/build/tools/network/curl/index.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
 export function registerCurl(server) {
-    server.tool("curl", "Make HTTP requests (GET, POST, etc.) like curl", {
-        url: z.string().describe("URL to request"),
-        method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"]).default("GET").describe("HTTP method"),
-        headers: z.record(z.string()).optional().describe("Request headers (object of key-value pairs)"),
-        body: z.string().optional().describe("Request body (for POST/PUT/PATCH)")
+    server.registerTool("curl", {
+        description: "Make HTTP requests to web endpoints. Example: GET request to an API or POST data to a server",
+        inputSchema: {
+            url: z.string().describe("URL to request"),
+            method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"]).default("GET").describe("HTTP method"),
+            headers: z.record(z.string()).optional().describe("Request headers (object of key-value pairs)"),
+            body: z.string().optional().describe("Request body (for POST/PUT/PATCH)")
+        }
     }, async ({ url, method, headers, body }) => {
         try {
             const controller = new AbortController();
@@ -27,7 +30,9 @@ export function registerCurl(server) {
         }
         catch (error) {
             if (error.name === 'AbortError') {
-                return { content: [{ type: "text", text: `curl failed: Request timeout (10s)` }] };
+                return {
+                    isError: true, content: [{ type: "text", text: `curl failed: Request timeout (10s)` }]
+                };
             }
             return { content: [{ type: "text", text: `curl failed: ${error.message || error}` }] };
         }

package/build/tools/network/dig/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import dns from "dns";
 export function registerDig(server) {
-    server.tool("dig", "Perform DNS lookup with dig command", {
-        target: z.string().describe("Hostname or IP address"),
-        type: z.string().default("A").describe("DNS record type")
+    server.registerTool("dig", {
+        description: "Perform DNS lookup with dig command",
+        inputSchema: {
+            target: z.string().describe("Hostname or IP address"),
+            type: z.string().default("A").describe("DNS record type")
+        }
     }, async ({ target, type }) => {
         return new Promise((resolve) => {
             dns.resolve(target, type, (err, addresses) => {

package/build/tools/network/grep/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerGrep(server) {
-    server.tool("grep", "Search for patterns in files", {
-        pattern: z.string().describe("Pattern to search for"),
-        file: z.string().describe("File path")
+    server.registerTool("grep", {
+        description: "Search for patterns in files",
+        inputSchema: {
+            pattern: z.string().describe("Pattern to search for"),
+            file: z.string().describe("File path")
+        }
     }, async ({ pattern, file }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

package/build/tools/network/head/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerHead(server) {
-    server.tool("head", "Display the beginning of a file", {
-        file: z.string().describe("File path"),
-        lines: z.number().default(10).describe("Number of lines")
+    server.registerTool("head", {
+        description: "Display the beginning of a file",
+        inputSchema: {
+            file: z.string().describe("File path"),
+            lines: z.number().default(10).describe("Number of lines")
+        }
     }, async ({ file, lines }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

package/build/tools/network/iban-validate/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerIbanValidate(server) {
-    server.tool("iban-validate", "Validate and parse IBAN (International Bank Account Number)", {
-        iban: z.string().describe("IBAN to validate and parse"),
+    server.registerTool("iban-validate", {
+        description: "Validate and parse IBAN (International Bank Account Number)",
+        inputSchema: {
+            iban: z.string().describe("IBAN to validate and parse"),
+        }
     }, async ({ iban }) => {
         try {
             const IBAN = (await import("iban")).default;

package/build/tools/network/ip-range-to-cidr/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerIpRangeToCidr(server) {
-    server.tool("ip-range-to-cidr", "Convert IP address range to CIDR notation(s)", {
-        startIP: z.string().describe("Starting IP address"),
-        endIP: z.string().describe("Ending IP address")
+    server.registerTool("ip-range-to-cidr", {
+        description: "Convert IP address range to CIDR notation(s)",
+        inputSchema: {
+            startIP: z.string().describe("Starting IP address"),
+            endIP: z.string().describe("Ending IP address")
+        }
     }, async ({ startIP, endIP }) => {
         try {
             // Parse IP addresses

package/build/tools/network/ip-subnet-calculator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerIpSubnetCalculator(server) {
-    server.tool("ip-subnet-calculator", "Calculate subnet information for IPv4", {
-        ip: z.string().describe("IPv4 address (e.g., 192.168.1.1)"),
-        cidr: z.number().describe("CIDR notation (e.g., 24)"),
+    server.registerTool("ip-subnet-calculator", {
+        description: "Calculate subnet information for IPv4",
+        inputSchema: {
+            ip: z.string().describe("IPv4 address (e.g., 192.168.1.1)"),
+            cidr: z.number().describe("CIDR notation (e.g., 24)"),
+        }
     }, async ({ ip, cidr }) => {
         try {
             if (cidr < 1 || cidr > 32) {

package/build/tools/network/ipv4-subnet-calc/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerIpv4SubnetCalc(server) {
-    server.tool("ipv4-subnet-calc", "Calculate IPv4 subnet information", {
-        cidr: z.string().describe("IPv4 CIDR notation (e.g., 192.168.1.0/24)"),
+    server.registerTool("ipv4-subnet-calc", {
+        description: "Calculate IPv4 subnet information",
+        inputSchema: {
+            cidr: z.string().describe("IPv4 CIDR notation (e.g., 192.168.1.0/24)"),
+        }
     }, async ({ cidr }) => {
         try {
             const [ip, prefixLength] = cidr.split('/');

package/build/tools/network/ipv6-subnet-calculator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerIpv6SubnetCalculator(server) {
-    server.tool("ipv6-subnet-calculator", "Calculate IPv6 subnet information", {
-        ipv6: z.string().describe("IPv6 address and prefix (e.g., 2001:db8::/32)"),
-        newPrefix: z.number().optional().describe("New prefix length for subnetting")
+    server.registerTool("ipv6-subnet-calculator", {
+        description: "Calculate IPv6 subnet information",
+        inputSchema: {
+            ipv6: z.string().describe("IPv6 address and prefix (e.g., 2001:db8::/32)"),
+            newPrefix: z.number().optional().describe("New prefix length for subnetting")
+        }
     }, async ({ ipv6, newPrefix }) => {
         try {
             const [address, prefixStr] = ipv6.split('/');

package/build/tools/network/ipv6-ula-generator/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerIpv6UlaGenerator(server) {
-    server.tool("ipv6-ula-generator", "Generate IPv6 Unique Local Address (ULA) prefix", {
-        globalId: z.string().optional().describe("Global ID (40 bits in hex, auto-generated if not provided)"),
+    server.registerTool("ipv6-ula-generator", {
+        description: "Generate IPv6 Unique Local Address (ULA) prefix",
+        inputSchema: {
+            globalId: z.string().optional().describe("Global ID (40 bits in hex, auto-generated if not provided)"),
+        }
     }, async ({ globalId }) => {
         try {
             // Generate random 40-bit Global ID if not provided

package/build/tools/network/mac-address-generate/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerMacAddressGenerate(server) {
-    server.tool("mac-address-generate", "Generate random MAC address", {
-        prefix: z.string().optional().describe("MAC address prefix (e.g., '00:1B:44')"),
-        separator: z.enum([":", "-"]).describe("Separator character").optional(),
+    server.registerTool("mac-address-generate", {
+        description: "Generate random MAC address",
+        inputSchema: {
+            prefix: z.string().optional().describe("MAC address prefix (e.g., '00:1B:44')"),
+            separator: z.enum([":", "-"]).describe("Separator character").optional(),
+        }
     }, async ({ prefix, separator = ":" }) => {
         try {
             let macParts = [];

package/build/tools/network/nslookup/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import dns from "dns";
 export function registerNslookup(server) {
-    server.tool("nslookup", "Perform DNS lookup on a hostname or IP address", {
-        target: z.string().describe("Hostname or IP address")
+    server.registerTool("nslookup", {
+        description: "Perform DNS lookup on a hostname or IP address",
+        inputSchema: {
+            target: z.string().describe("Hostname or IP address")
+        }
     }, async ({ target }) => {
         return new Promise((resolve) => {
             dns.lookup(target, (err, address, family) => {

package/build/tools/network/ping/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import ping from "ping";
 export function registerPing(server) {
-    server.tool("ping", "Ping a host to check connectivity", {
-        target: z.string().describe("Host to ping"),
-        count: z.number().default(4).describe("Number of ping attempts")
+    server.registerTool("ping", {
+        description: "Test network connectivity to a host. Example: ping google.com to check if it's reachable",
+        inputSchema: {
+            target: z.string().describe("Host to ping"),
+            count: z.number().default(4).describe("Number of ping attempts")
+        }
     }, async ({ target, count }) => {
         try {
             const res = await ping.promise.probe(target, { min_reply: count });
@@ -14,7 +17,9 @@ export function registerPing(server) {
             };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }] };
+            return {
+                isError: true, content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }]
+            };
         }
     });
 }

package/build/tools/network/ps/index.js

@@ -1,6 +1,9 @@
 import psList from "ps-list";
 export function registerPs(server) {
-    server.tool("ps", "List running processes", {}, async () => {
+    server.registerTool("ps", {
+        description: "List running processes",
+        inputSchema: {}
+    }, async () => {
         try {
             const processes = await psList();
             // Defensive: handle missing properties and filter out bad entries

package/build/tools/network/random-port/index.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
 export function registerRandomPort(server) {
-    server.tool("random-port", "Generate random port numbers", {
-        count: z.number().describe("Number of ports to generate").optional(),
-        min: z.number().describe("Minimum port number").optional(),
-        max: z.number().describe("Maximum port number").optional(),
-        exclude: z.array(z.number()).optional().describe("Ports to exclude"),
+    server.registerTool("random-port", {
+        description: "Generate random port numbers",
+        inputSchema: {
+            count: z.number().describe("Number of ports to generate").optional(),
+            min: z.number().describe("Minimum port number").optional(),
+            max: z.number().describe("Maximum port number").optional(),
+            exclude: z.array(z.number()).optional().describe("Ports to exclude"),
+        }
     }, async ({ count = 1, min = 1024, max = 65535, exclude = [] }) => {
         try {
             const ports = [];

package/build/tools/network/scp/index.js

@@ -37,13 +37,16 @@ function resolvePrivateKey(privateKeyArg) {
     return privateKeyArg;
 }
 export function registerScp(server) {
-    server.tool("scp", "Copy files to or from a remote host using SFTP (SCP-like)", {
-        target: z.string().describe("Target host"),
-        user: z.string().describe("Username"),
-        direction: z.enum(["upload", "download"]).describe("Direction: upload (local to remote) or download (remote to local)"),
-        localPath: z.string().describe("Local file path (source for upload, destination for download)"),
-        remotePath: z.string().describe("Remote file path (destination for upload, source for download)"),
-        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    server.registerTool("scp", {
+        description: "Copy files to or from a remote host using SFTP (SCP-like)",
+        inputSchema: {
+            target: z.string().describe("Target host"),
+            user: z.string().describe("Username"),
+            direction: z.enum(["upload", "download"]).describe("Direction: upload (local to remote) or download (remote to local)"),
+            localPath: z.string().describe("Local file path (source for upload, destination for download)"),
+            remotePath: z.string().describe("Remote file path (destination for upload, source for download)"),
+            privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+        }
     }, async ({ target, user, direction, localPath, remotePath, privateKey }) => {
         try {
             const { Client } = await import("ssh2");

package/build/tools/network/ssh/index.js

@@ -38,11 +38,14 @@ function resolvePrivateKey(privateKeyArg) {
     return privateKeyArg;
 }
 export function registerSsh(server) {
-    server.tool("ssh", "Connect to a target via SSH", {
-        target: z.string().describe("Target host"),
-        user: z.string().describe("Username"),
-        command: z.string().describe("Command to run on remote host"),
-        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    server.registerTool("ssh", {
+        description: "Connect to a target via SSH",
+        inputSchema: {
+            target: z.string().describe("Target host"),
+            user: z.string().describe("Username"),
+            command: z.string().describe("Command to run on remote host"),
+            privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+        }
     }, async ({ target, user, command, privateKey }) => {
         return new Promise((resolve) => {
             let resolvedKey;

package/build/tools/network/tail/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import readLastLines from "read-last-lines";
 export function registerTail(server) {
-    server.tool("tail", "Display the end of a file", {
-        file: z.string().describe("File path"),
-        lines: z.number().default(10).describe("Number of lines")
+    server.registerTool("tail", {
+        description: "Display the end of a file",
+        inputSchema: {
+            file: z.string().describe("File path"),
+            lines: z.number().default(10).describe("Number of lines")
+        }
     }, async ({ file, lines }) => {
         try {
             const out = await readLastLines.read(file, lines);

package/build/tools/network/telnet/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerTelnet(server) {
-    server.tool("telnet", "Test TCP connectivity to a host and port", {
-        target: z.string().describe("Host to connect to"),
-        port: z.number().describe("Port number")
+    server.registerTool("telnet", {
+        description: "Test TCP connectivity to a host and port",
+        inputSchema: {
+            target: z.string().describe("Host to connect to"),
+            port: z.number().describe("Port number")
+        }
     }, async ({ target, port }) => {
         return new Promise(async (resolve) => {
             try {

package/build/tools/network/top/index.js

@@ -1,6 +1,9 @@
 import psList from "ps-list";
 export function registerTop(server) {
-    server.tool("top", "Display system processes (snapshot)", {}, async () => {
+    server.registerTool("top", {
+        description: "Display system processes (snapshot)",
+        inputSchema: {}
+    }, async () => {
         try {
             const processes = await psList();
             const sorted = processes.sort((a, b) => (b.cpu || 0) - (a.cpu || 0)).slice(0, 10);

package/build/tools/network/url-parse/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerUrlParse(server) {
-    server.tool("url-parse", "Parse URL into components", {
-        url: z.string().describe("URL to parse"),
+    server.registerTool("url-parse", {
+        description: "Parse URL into components",
+        inputSchema: {
+            url: z.string().describe("URL to parse"),
+        }
     }, async ({ url }) => {
         try {
             const urlObj = new URL(url);

package/build/tools/physics/angle-converter/index.js

@@ -1,13 +1,16 @@
 import { z } from "zod";
 export function registerAngleConverter(server) {
-    server.tool("angle-converter", "Convert between different angle units", {
-        value: z.number().describe("Angle value to convert"),
-        fromUnit: z.enum([
-            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
-        ]).describe("Source angle unit"),
-        toUnit: z.enum([
-            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
-        ]).describe("Target angle unit")
+    server.registerTool("angle-converter", {
+        description: "Convert between different angle units",
+        inputSchema: {
+            value: z.number().describe("Angle value to convert"),
+            fromUnit: z.enum([
+                "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+            ]).describe("Source angle unit"),
+            toUnit: z.enum([
+                "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+            ]).describe("Target angle unit")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to degrees

package/build/tools/physics/energy-converter/index.js

@@ -1,15 +1,18 @@
 import { z } from "zod";
 export function registerEnergyConverter(server) {
-    server.tool("energy-converter", "Convert between different energy units", {
-        value: z.number().describe("Energy value to convert"),
-        fromUnit: z.enum([
-            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
-            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
-        ]).describe("Source energy unit"),
-        toUnit: z.enum([
-            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
-            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
-        ]).describe("Target energy unit")
+    server.registerTool("energy-converter", {
+        description: "Convert between different energy units",
+        inputSchema: {
+            value: z.number().describe("Energy value to convert"),
+            fromUnit: z.enum([
+                "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+                "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+            ]).describe("Source energy unit"),
+            toUnit: z.enum([
+                "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+                "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+            ]).describe("Target energy unit")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to joules

package/build/tools/physics/power-converter/index.js

@@ -1,15 +1,18 @@
 import { z } from "zod";
 export function registerPowerConverter(server) {
-    server.tool("power-converter", "Convert between different power units", {
-        value: z.number().describe("Power value to convert"),
-        fromUnit: z.enum([
-            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
-            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
-        ]).describe("Source power unit"),
-        toUnit: z.enum([
-            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
-            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
-        ]).describe("Target power unit")
+    server.registerTool("power-converter", {
+        description: "Convert between different power units",
+        inputSchema: {
+            value: z.number().describe("Power value to convert"),
+            fromUnit: z.enum([
+                "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+                "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+            ]).describe("Source power unit"),
+            toUnit: z.enum([
+                "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+                "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+            ]).describe("Target power unit")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to watts

package/build/tools/text/ascii-art-text/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerAsciiArtText(server) {
-    server.tool("ascii-art-text", "Generate ASCII art text", {
-        text: z.string().describe("Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"),
-        font: z.string().describe("ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure.").optional(),
+    server.registerTool("ascii-art-text", {
+        description: "Generate ASCII art text",
+        inputSchema: {
+            text: z.string().describe("Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"),
+            font: z.string().describe("ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure.").optional(),
+        }
     }, async ({ text, font = "standard" }) => {
         try {
             // Generate ASCII art using figlet

package/build/tools/text/distinct-words/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerDistinctWords(server) {
-    server.tool("distinct-words", "Count distinct words in text and show their frequency", {
-        text: z.string().describe("Text to analyze for distinct words")
+    server.registerTool("distinct-words", {
+        description: "Count distinct words in text and show their frequency",
+        inputSchema: {
+            text: z.string().describe("Text to analyze for distinct words")
+        }
     }, async ({ text }) => {
         // Remove punctuation and split into words
         const cleanedText = text.replace(/[^\w\s]/g, ' ').toLowerCase();

package/build/tools/text/emoji-search/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerEmojiSearch(server) {
-    server.tool("emoji-search", "Search for emojis by name or category", {
-        query: z.string().describe("Search term for emoji (name, category, or keyword)"),
+    server.registerTool("emoji-search", {
+        description: "Search for emojis by name or category",
+        inputSchema: {
+            query: z.string().describe("Search term for emoji (name, category, or keyword)"),
+        }
     }, async ({ query }) => {
         try {
             // Basic emoji database (simplified)

package/build/tools/text/lorem-ipsum-generator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerLoremIpsumGenerator(server) {
-    server.tool("lorem-ipsum-generator", "Generate Lorem Ipsum placeholder text", {
-        count: z.number().describe("Number of items to generate").optional(),
-        type: z.enum(["words", "sentences", "paragraphs"]).describe("Type of content to generate").optional(),
+    server.registerTool("lorem-ipsum-generator", {
+        description: "Generate Lorem Ipsum placeholder text",
+        inputSchema: {
+            count: z.number().describe("Number of items to generate").optional(),
+            type: z.enum(["words", "sentences", "paragraphs"]).describe("Type of content to generate").optional(),
+        }
     }, async ({ count = 5, type = "sentences" }) => {
         try {
             if (count < 1 || count > 100) {

package/build/tools/text/numeronym-generator/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerNumeronymGenerator(server) {
-    server.tool("numeronym-generator", "Generate numeronyms (abbreviations with numbers) from text", {
-        text: z.string().describe("Text to convert to numeronym"),
+    server.registerTool("numeronym-generator", {
+        description: "Generate numeronyms (abbreviations with numbers) from text",
+        inputSchema: {
+            text: z.string().describe("Text to convert to numeronym"),
+        }
     }, async ({ text }) => {
         try {
             const words = text.trim().split(/\s+/);

package/build/tools/text/slugify-string/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerSlugifyString(server) {
-    server.tool("slugify-string", "Convert text to URL-friendly slug format", {
-        text: z.string().describe("Text to convert to slug"),
-        separator: z.string().describe("Character to use as separator").optional(),
-        lowercase: z.boolean().describe("Convert to lowercase").optional(),
+    server.registerTool("slugify-string", {
+        description: "Convert text to URL-friendly slug format",
+        inputSchema: {
+            text: z.string().describe("Text to convert to slug"),
+            separator: z.string().describe("Character to use as separator").optional(),
+            lowercase: z.boolean().describe("Convert to lowercase").optional(),
+        }
     }, async ({ text, separator = "-", lowercase = true }) => {
         try {
             let slug = text

package/build/tools/text/string-obfuscator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerStringObfuscator(server) {
-    server.tool("string-obfuscator", "Obfuscate text by replacing characters with their HTML entities or other representations", {
-        text: z.string().describe("Text to obfuscate"),
-        method: z.enum(["html-entities", "unicode", "base64"]).describe("Obfuscation method").optional(),
+    server.registerTool("string-obfuscator", {
+        description: "Obfuscate text by replacing characters with their HTML entities or other representations",
+        inputSchema: {
+            text: z.string().describe("Text to obfuscate"),
+            method: z.enum(["html-entities", "unicode", "base64"]).describe("Obfuscation method").optional(),
+        }
     }, async ({ text, method = "html-entities" }) => {
         try {
             let result = '';