it-tools-mcp 3.6.0 → 4.1.1

package/build/tools/{dataFormat/toml-to-json → data_format/convert_toml_to_json}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerTomlToJson(server) {
-    server.registerTool("toml-to-json", {
+export function registerConvertTomlJson(server) {
+    server.registerTool("convert_toml_to_json", {
         description: "Convert TOML to JSON format",
         inputSchema: {
             toml: z.string().describe("TOML string to convert"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Toml To Json",
+            description: "Convert TOML to JSON format",
+            readOnlyHint: false
         }
     }, async ({ toml: tomlString }) => {
         try {

package/build/tools/{dataFormat/json-format → data_format/format_json}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerJsonFormat(server) {
-    server.registerTool("json-format", {
-        description: 'Format and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON',
+export function registerFormatJson(server) {
+    server.registerTool("format_json", {
+        description: 'Format and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON with customizable spacing',
         inputSchema: {
             json: z.string().describe("JSON string to format"),
             indent: z.number().describe("Number of spaces for indentation").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format JSON",
+            description: "Format and prettify JSON with proper indentation and customizable spacing",
+            readOnlyHint: false
         }
     }, async ({ json, indent = 2 }) => {
         try {

package/build/tools/{dataFormat/phone-format → data_format/format_phone}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerPhoneFormat(server) {
-    server.registerTool("phone-format", {
+export function registerFormatPhone(server) {
+    server.registerTool("format_phone", {
         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')"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Phone",
+            description: "Parse and format phone numbers",
+            readOnlyHint: false
         }
     }, async ({ phoneNumber, countryCode }) => {
         try {

package/build/tools/{dataFormat/sql-format → data_format/format_sql}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerSqlFormat(server) {
-    server.registerTool("sql-format", {
+export function registerFormatSql(server) {
+    server.registerTool("format_sql", {
         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'."),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Sql",
+            description: "Format and prettify SQL queries",
+            readOnlyHint: false
         }
     }, async ({ sql, dialect = "sql" }) => {
         try {

package/build/tools/{dataFormat/xml-format → data_format/format_xml}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerXmlFormat(server) {
-    server.registerTool("xml-format", {
+export function registerFormatXml(server) {
+    server.registerTool("format_xml", {
         description: "Format and prettify XML",
         inputSchema: {
             xml: z.string().describe("XML string to format"),
             indent: z.number().describe("Number of spaces for indentation").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Xml",
+            description: "Format and prettify XML",
+            readOnlyHint: false
         }
     }, async ({ xml, indent = 2 }) => {
         try {

package/build/tools/{dataFormat/yaml-format → data_format/format_yaml}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerYamlFormat(server) {
-    server.registerTool("yaml-format", {
+export function registerFormatYaml(server) {
+    server.registerTool("format_yaml", {
         description: "Format and prettify YAML",
         inputSchema: {
             yaml: z.string().describe("YAML string to format"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Yaml",
+            description: "Format and prettify YAML",
+            readOnlyHint: false
         }
     }, async ({ yaml }) => {
         try {

package/build/tools/{dataFormat/json-minify → data_format/minify_json}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerJsonMinify(server) {
-    server.registerTool("json-minify", {
-        description: "Minify JSON by removing whitespace",
+export function registerMinifyJson(server) {
+    server.registerTool("minify_json", {
+        description: "Minify JSON by removing whitespace and unnecessary characters. Example: formatted JSON → compact single-line JSON",
         inputSchema: {
             json: z.string().describe("JSON string to minify"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Minify JSON",
+            description: "Remove whitespace and minify JSON to compact format",
+            readOnlyHint: false
         }
     }, async ({ json }) => {
         try {

package/build/tools/development/{list-converter → convert_list}/index.js

@@ -1,12 +1,18 @@
 import { z } from "zod";
-export function registerListConverter(server) {
-    server.registerTool("list-converter", {
+export function registerConvertList(server) {
+    server.registerTool("convert_list", {
         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(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert List",
+            description: "Convert between different list formats (comma-separated, line-separated, etc",
+            readOnlyHint: false
         }
     }, async ({ list, inputFormat, outputFormat, trim = true }) => {
         try {

package/build/tools/development/{html-prettifier → format_html}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerHtmlPrettifier(server) {
-    server.registerTool("html-prettifier", {
+export function registerPrettifyHtml(server) {
+    server.registerTool("format_html", {
         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")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Html",
+            description: "Format and beautify HTML code",
+            readOnlyHint: false
         }
     }, async ({ html, indentSize }) => {
         try {

package/build/tools/development/{javascript-prettifier → format_javascript}/index.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
-export function registerJavascriptPrettifier(server) {
-    server.registerTool("javascript-prettifier", {
+export function registerPrettifyJavascript(server) {
+    server.registerTool("format_javascript", {
         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")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Javascript",
+            description: "Format and beautify JavaScript/CSS code",
+            readOnlyHint: false
         }
     }, async ({ code, type, indentSize }) => {
         try {

package/build/tools/development/{crontab-generate → generate_crontab}/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { CronExpressionParser } from 'cron-parser';
-export function registerCrontabGenerate(server) {
-    server.registerTool("crontab-generate", {
+export function registerGenerateCrontab(server) {
+    server.registerTool("generate_crontab", {
         description: "Generate crontab expressions",
         inputSchema: {
             minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
@@ -9,6 +9,12 @@ export function registerCrontabGenerate(server) {
             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(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Crontab",
+            description: "Generate crontab expressions",
+            readOnlyHint: false
         }
     }, async ({ minute = "*", hour = "*", dayOfMonth = "*", month = "*", dayOfWeek = "*" }) => {
         try {

package/build/tools/development/{markdown-toc-generator → generate_markdown_toc}/index.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
-export function registerMarkdownTocGenerator(server) {
-    server.registerTool("markdown-toc-generator", {
+export function registerGenerateMarkdownToc(server) {
+    server.registerTool("generate_markdown_toc", {
         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")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Markdown Toc",
+            description: "Generate a table of contents from Markdown headers",
+            readOnlyHint: false
         }
     }, async ({ markdown, maxLevel, generateAnchors }) => {
         // Extract headers from markdown

package/build/tools/development/{regex-tester → test_regex}/index.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
-export function registerRegexTester(server) {
-    server.registerTool("regex-tester", {
+export function registerTestRegex(server) {
+    server.registerTool("test_regex", {
         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)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Test Regex",
+            description: "Test regular expressions against text",
+            readOnlyHint: false
         }
     }, async ({ pattern, text, flags }) => {
         try {

package/build/tools/docker/{docker-compose-to-docker-run → convert_docker_compose_to_run}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerComposeToRun(server) {
-    server.registerTool("docker-compose-to-docker-run", {
+    server.registerTool("convert_docker_compose_to_run", {
         description: "Convert Docker Compose files to docker run commands",
         inputSchema: {
             content: z.string().describe("Docker Compose file content to convert"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Docker Compose To Run",
+            description: "Convert Docker Compose files to docker run commands",
+            readOnlyHint: false
         }
     }, async ({ content }) => {
         if (!content?.trim()) {

package/build/tools/docker/{docker-run-to-docker-compose → convert_docker_run_to_compose}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerRunToCompose(server) {
-    server.registerTool("docker-run-to-docker-compose", {
+    server.registerTool("convert_docker_run_to_compose", {
         description: "Convert docker run commands to Docker Compose format",
         inputSchema: {
             commands: z.string().describe("Docker run commands to convert (one per line)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Docker Run To Compose",
+            description: "Convert docker run commands to Docker Compose format",
+            readOnlyHint: false
         }
     }, async ({ commands }) => {
         if (!commands?.trim()) {

package/build/tools/docker/{traefik-compose-generator → generate_traefik_compose}/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import yaml from "js-yaml";
-export function registerTraefikComposeGenerator(server) {
-    server.registerTool("traefik-compose-generator", {
+export function registerGenerateTraefik(server) {
+    server.registerTool("generate_traefik_compose", {
         description: "Generate Traefik Docker Compose configuration",
         inputSchema: {
             domain: z.string().optional().describe("Domain for Traefik services (default: example.com)"),
@@ -9,6 +9,12 @@ export function registerTraefikComposeGenerator(server) {
             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)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Traefik Compose",
+            description: "Generate Traefik Docker Compose configuration",
+            readOnlyHint: false
         }
     }, async ({ domain = 'example.com', email = 'admin@example.com', network = 'traefik', serviceName = 'webapp', serviceImage = 'nginx:latest' }) => {
         try {

package/build/tools/docker/{docker-reference → show_docker_reference}/index.js

@@ -1,7 +1,13 @@
-export function registerDockerReference(server) {
-    server.registerTool("docker-reference", {
+export function registerReferenceDocker(server) {
+    server.registerTool("show_docker_reference", {
         description: "Get Docker commands reference and cheatsheet",
-        inputSchema: {}
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Show Docker Reference",
+            description: "Get Docker commands reference and cheatsheet",
+            readOnlyHint: true
+        }
     }, async () => {
         const reference = `# Docker Quick Reference
 

package/build/tools/docker/{docker-compose-validator → validate_docker_compose}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
 import yaml from "js-yaml";
-export function registerDockerComposeValidator(server) {
-    server.registerTool("docker-compose-validator", {
-        description: "Validate Docker Compose files for syntax and compatibility",
+export function registerValidateCompose(server) {
+    server.registerTool("validate_docker_compose", {
+        description: "Validate Docker Compose files for syntax errors, compatibility issues, and best practices. Example: check YAML syntax, service configuration, network setup",
         inputSchema: {
             content: z.string().describe("Docker Compose file content to validate"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Validate Docker Compose",
+            description: "Validate Docker Compose syntax and configuration",
+            readOnlyHint: false
         }
     }, async ({ content }) => {
         if (!content?.trim()) {

package/build/tools/encoding/{text-to-binary → convert_text_to_binary}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerTextToBinary(server) {
-    server.registerTool("text-to-binary", {
+export function registerConvertTextBinary(server) {
+    server.registerTool("convert_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"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Binary",
+            description: "Convert text to binary and vice versa",
+            readOnlyHint: false
         }
     }, async ({ input, operation }) => {
         try {

package/build/tools/encoding/{base64-decode → decode_base64}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerBase64Decode(server) {
-    server.registerTool("base64-decode", {
+export function registerDecodeBase64(server) {
+    server.registerTool("decode_base64", {
         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"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Base64",
+            description: "Decode Base64 text back to original text",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         try {

package/build/tools/encoding/{html-decode → decode_html}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerHtmlDecode(server) {
-    server.registerTool("html-decode", {
+export function registerDecodeHtml(server) {
+    server.registerTool("decode_html", {
         description: "Decode HTML entities",
         inputSchema: {
             text: z.string().describe("HTML encoded text to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Html",
+            description: "Decode HTML entities",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         const decoded = text

package/build/tools/encoding/{url-decode → decode_url}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerUrlDecode(server) {
-    server.registerTool("url-decode", {
+export function registerDecodeUrl(server) {
+    server.registerTool("decode_url", {
         description: "URL decode text",
         inputSchema: {
             text: z.string().describe("URL encoded text to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Url",
+            description: "URL decode text",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         try {

package/build/tools/encoding/{base64-encode → encode_base64}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerBase64Encode(server) {
-    server.registerTool("base64-encode", {
+export function registerEncodeBase64(server) {
+    server.registerTool("encode_base64", {
         description: 'Encode text to Base64 format. Example: "Hello World" → "SGVsbG8gV29ybGQ="',
         inputSchema: {
             text: z.string().min(1).describe("Text to encode to Base64"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Base64",
+            description: "Encode text to Base64 format",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         try {

package/build/tools/encoding/{html-encode → encode_html}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerHtmlEncode(server) {
-    server.registerTool("html-encode", {
+export function registerEncodeHtml(server) {
+    server.registerTool("encode_html", {
         description: "Encode HTML entities",
         inputSchema: {
             text: z.string().describe("Text to HTML encode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Html",
+            description: "Encode HTML entities",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         const encoded = text

package/build/tools/encoding/{html-entities-extended → encode_html_entities}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerHtmlEntitiesExtended(server) {
-    server.registerTool("html-entities-extended", {
+export function registerEncodeHtmlEntities(server) {
+    server.registerTool("encode_html_entities", {
         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"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Html Entities",
+            description: "Extended HTML entity encoding/decoding",
+            readOnlyHint: false
         }
     }, async ({ text, operation }) => {
         try {

package/build/tools/encoding/{url-encode → encode_url}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerUrlEncode(server) {
-    server.registerTool("url-encode", {
+export function registerEncodeUrl(server) {
+    server.registerTool("encode_url", {
         description: "URL encode text",
         inputSchema: {
             text: z.string().describe("Text to URL encode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Url",
+            description: "URL encode text",
+            readOnlyHint: false
         }
     }, async ({ text }) => {
         const encoded = encodeURIComponent(text);

package/build/tools/forensic/{safelink-decoder → decode_safelink}/index.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-export function registerSafelinkDecoder(server) {
-    server.registerTool("safelink-decoder", {
+export function registerDecodeSafelink(server) {
+    server.registerTool("decode_safelink", {
         description: "Decode Microsoft Outlook SafeLink URLs",
         inputSchema: {
             safelink: z.string().describe("SafeLink URL to decode")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Safelink",
+            description: "Decode Microsoft Outlook SafeLink URLs",
+            readOnlyHint: false
         }
     }, async ({ safelink }) => {
         try {

package/build/tools/forensic/{url-fanger → fang_url}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerUrlFanger(server) {
-    server.registerTool("url-fanger", {
+export function registerFangUrl(server) {
+    server.registerTool("fang_url", {
         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")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Fang Url",
+            description: "Defang or refang URLs for safe sharing (security analysis)",
+            readOnlyHint: false
         }
     }, async ({ text, operation }) => {
         try {

package/build/tools/forensic/{file-type-identifier → identify_file_type}/index.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
 import { Buffer } from 'buffer';
-export function registerFileTypeIdentifier(server) {
-    server.registerTool("file-type-identifier", {
+export function registerIdentifyFileType(server) {
+    server.registerTool("identify_file_type", {
         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")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Identify File Type",
+            description: "Identify file type based on magic numbers/file signatures",
+            readOnlyHint: false
         }
     }, async ({ data, format }) => {
         try {

package/build/tools/{idGenerators/qr-generate → id_generators/generate_qr_code}/index.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-export function registerQrGenerate(server) {
-    server.registerTool("qr-generate", {
+export function registerGenerateQr(server) {
+    server.registerTool("generate_qr_code", {
         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(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Qr Code",
+            description: "Generate QR code for any text including URLs, WiFi networks, contact info, etc",
+            readOnlyHint: false
         }
     }, async ({ text, size = 1 }) => {
         try {

package/build/tools/{idGenerators/svg-placeholder-generator → id_generators/generate_svg_placeholder}/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-export function registerSvgPlaceholderGenerator(server) {
-    server.registerTool("svg-placeholder-generator", {
+export function registerGenerateSvgPlaceholder(server) {
+    server.registerTool("generate_svg_placeholder", {
         description: "Generate SVG placeholder images",
         inputSchema: {
             width: z.number().describe("Width in pixels").optional(),
@@ -8,6 +8,12 @@ export function registerSvgPlaceholderGenerator(server) {
             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)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Svg Placeholder",
+            description: "Generate SVG placeholder images",
+            readOnlyHint: false
         }
     }, async ({ width = 300, height = 200, backgroundColor = "#cccccc", textColor = "#666666", text }) => {
         try {