tool.david888.com

{
  "name": "list_888_tools",
  "kind": "answer",
  "impl": "imperative",
  "description": "List or search all available developer and IT tools on 888tools (tool.david888.com), including categories, paths, keywords, and descriptions.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "category": {
        "type": "string",
        "description": "Optional category name to filter by (e.g. \"Crypto\", \"Converter\", \"Web\", \"Text\", \"Images and videos\", \"Development\", \"Network\", \"Measurement\")"
      },
      "search": {
        "type": "string",
        "description": "Optional keyword to search tool names, descriptions, and tags"
      },
      "limit": {
        "type": "number",
        "description": "Maximum number of tools to return (default: 50)"
      }
    }
  },
  "page": "/"
}

{
  "name": "convert_chinese_text",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert text between Traditional Chinese (繁體中文) and Simplified Chinese (簡體中文) with OpenCC dictionary support (including Taiwan idiom phrases and standard conversion).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "The Chinese text to convert"
      },
      "direction": {
        "type": "string",
        "enum": [
          "s2t",
          "t2s",
          "s2twp",
          "s2tw"
        ],
        "description": "Conversion mode: \"s2t\" (Simplified to Traditional with Taiwan phrases), \"t2s\" (Traditional to Simplified), \"s2twp\" (Simplified to Traditional with Taiwan phrases), \"s2tw\" (Simplified to Traditional characters only)",
        "default": "s2t"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "generate_uuid",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate universally unique identifiers (UUID version 4 or version 1) with options for quantity, uppercase, and hyphen removal.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "version": {
        "type": "string",
        "enum": [
          "v4",
          "v1"
        ],
        "description": "UUID version to generate (default: \"v4\")",
        "default": "v4"
      },
      "count": {
        "type": "number",
        "description": "Number of UUIDs to generate (1 to 100, default: 1)",
        "default": 1
      },
      "uppercase": {
        "type": "boolean",
        "description": "Whether to output uppercase UUIDs (default: false)",
        "default": false
      },
      "removeHyphens": {
        "type": "boolean",
        "description": "Whether to remove hyphens (dashes) from generated UUIDs (default: false)",
        "default": false
      }
    }
  },
  "page": "/"
}

{
  "name": "generate_ulid",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate Universally Unique Lexicographically Sortable Identifiers (ULID) with millisecond timestamp ordering.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "count": {
        "type": "number",
        "description": "Number of ULIDs to generate (1 to 100, default: 1)",
        "default": 1
      },
      "lowercase": {
        "type": "boolean",
        "description": "Whether to output lowercase ULIDs (default: false)",
        "default": false
      }
    }
  },
  "page": "/"
}

{
  "name": "base64_encode",
  "kind": "act",
  "impl": "imperative",
  "description": "Encode text string to standard Base64 or URL-safe Base64 format.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "The plain text string to encode"
      },
      "urlSafe": {
        "type": "boolean",
        "description": "Whether to make the output URL-safe (replacing + with - and / with _)",
        "default": false
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "base64_decode",
  "kind": "act",
  "impl": "imperative",
  "description": "Decode standard Base64 or URL-safe Base64 back into plain text string.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "base64": {
        "type": "string",
        "description": "The Base64 string to decode"
      },
      "urlSafe": {
        "type": "boolean",
        "description": "Whether the input is URL-safe Base64",
        "default": false
      }
    },
    "required": [
      "base64"
    ]
  },
  "page": "/"
}

{
  "name": "hash_text",
  "kind": "act",
  "impl": "imperative",
  "description": "Compute cryptographic hashes (MD5, SHA1, SHA224, SHA256, SHA384, SHA512, SHA3, RIPEMD160) for text with Hex, Base64, or Binary output encoding.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Text string to hash"
      },
      "algorithm": {
        "type": "string",
        "enum": [
          "MD5",
          "SHA1",
          "SHA224",
          "SHA256",
          "SHA384",
          "SHA512",
          "SHA3",
          "RIPEMD160",
          "ALL"
        ],
        "description": "Hash algorithm to use (or \"ALL\" to return all supported hashes)",
        "default": "SHA256"
      },
      "encoding": {
        "type": "string",
        "enum": [
          "Hex",
          "Base64",
          "Bin"
        ],
        "description": "Output encoding format (default: \"Hex\")",
        "default": "Hex"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "convert_text_case",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert string between various naming cases: camelCase, snake_case, kebab-case, PascalCase, CONSTANT_CASE, sentence case, dot.case, path/case, or generate all at once.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Input text string to transform"
      },
      "targetCase": {
        "type": "string",
        "enum": [
          "camelCase",
          "snakeCase",
          "paramCase",
          "pascalCase",
          "constantCase",
          "sentenceCase",
          "capitalCase",
          "dotCase",
          "pathCase",
          "lowerCase",
          "upperCase",
          "ALL"
        ],
        "description": "Target case transformation, or \"ALL\" for all casing styles",
        "default": "camelCase"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "slugify_string",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate URL-friendly and safe slug strings from arbitrary text (removes special chars, handles accents, converts spaces to hyphens).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Text string to slugify"
      },
      "separator": {
        "type": "string",
        "description": "Character to separate words with (default: \"-\")",
        "default": "-"
      },
      "lowercase": {
        "type": "boolean",
        "description": "Whether to convert the slug to lowercase (default: true)",
        "default": true
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "format_or_minify_json",
  "kind": "act",
  "impl": "imperative",
  "description": "Validate, format (pretty-print) or minify JSON data with custom indentation.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "json": {
        "type": "string",
        "description": "The JSON string to format or minify"
      },
      "action": {
        "type": "string",
        "enum": [
          "format",
          "minify",
          "validate"
        ],
        "description": "Operation to perform: \"format\" (pretty-print), \"minify\" (compact one-line), or \"validate\"",
        "default": "format"
      },
      "indent": {
        "type": "number",
        "description": "Number of spaces for indentation when formatting (default: 2)",
        "default": 2
      }
    },
    "required": [
      "json"
    ]
  },
  "page": "/"
}

{
  "name": "inspect_jwt",
  "kind": "answer",
  "impl": "imperative",
  "description": "Decode and inspect a JSON Web Token (JWT) header and payload without verifying cryptographic signature.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "jwt": {
        "type": "string",
        "description": "The JWT string to decode (e.g. eyJhbGciOi...)"
      }
    },
    "required": [
      "jwt"
    ]
  },
  "page": "/"
}

{
  "name": "calculate_chmod",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert and calculate Linux/Unix chmod file permissions between Octal (e.g. 755, 644) and Symbolic (e.g. -rwxr-xr-x) formats.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "octal": {
        "type": "string",
        "description": "3-digit octal permission string (e.g. \"755\", \"644\", \"777\")"
      },
      "symbolic": {
        "type": "string",
        "description": "9 or 10 character symbolic permission string (e.g. \"rwxr-xr-x\" or \"-rw-r--r--\")"
      }
    }
  },
  "page": "/"
}

{
  "name": "decode_safelink",
  "kind": "act",
  "impl": "imperative",
  "description": "Decode Outlook / Microsoft Office 365 or Google SafeLinks protected URLs back into their original target destination URL.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "The SafeLinks protected URL (e.g. https://nam01.safelinks.protection.outlook.com/...)"
      }
    },
    "required": [
      "url"
    ]
  },
  "page": "/"
}

{
  "name": "url_encode_decode",
  "kind": "act",
  "impl": "imperative",
  "description": "Encode or decode URLs and URI query parameters.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "The URL or string to encode/decode"
      },
      "action": {
        "type": "string",
        "enum": [
          "encode",
          "decode",
          "parse"
        ],
        "description": "Operation: \"encode\" (encodeURIComponent), \"decode\" (decodeURIComponent), or \"parse\" (parse components)",
        "default": "encode"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "generate_bip39_mnemonic",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate or convert BIP39 cryptocurrency mnemonic seed phrase (12, 15, 18, 21, 24 words) and hex entropy in multiple languages.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "generate",
          "mnemonic_to_entropy",
          "entropy_to_mnemonic"
        ],
        "description": "Operation: \"generate\" (creates new mnemonic), \"mnemonic_to_entropy\", or \"entropy_to_mnemonic\"",
        "default": "generate"
      },
      "language": {
        "type": "string",
        "enum": [
          "english",
          "chinese_simplified",
          "chinese_traditional",
          "japanese",
          "korean",
          "french",
          "spanish",
          "italian",
          "portuguese",
          "czech"
        ],
        "description": "Wordlist language (default: \"english\")",
        "default": "english"
      },
      "wordsCount": {
        "type": "number",
        "enum": [
          12,
          15,
          18,
          21,
          24
        ],
        "description": "Number of words for newly generated mnemonic (default: 12)",
        "default": 12
      },
      "mnemonic": {
        "type": "string",
        "description": "Mnemonic phrase string (required when action is \"mnemonic_to_entropy\")"
      },
      "entropy": {
        "type": "string",
        "description": "Hex entropy string (required when action is \"entropy_to_mnemonic\")"
      }
    }
  },
  "page": "/"
}

{
  "name": "analyze_password_strength",
  "kind": "act",
  "impl": "imperative",
  "description": "Analyze password strength, calculate bit entropy, character set complexity, and estimated crack time.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "password": {
        "type": "string",
        "description": "Password string to analyze"
      }
    },
    "required": [
      "password"
    ]
  },
  "page": "/"
}

{
  "name": "generate_lorem_ipsum",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate placeholder Lorem Ipsum dummy text by paragraphs, sentences, or HTML markup.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "paragraphCount": {
        "type": "number",
        "description": "Number of paragraphs to generate (default: 2)",
        "default": 2
      },
      "sentencePerParagraph": {
        "type": "number",
        "description": "Number of sentences per paragraph (default: 4)",
        "default": 4
      },
      "wordCount": {
        "type": "number",
        "description": "Average number of words per sentence (default: 10)",
        "default": 10
      },
      "startWithLoremIpsum": {
        "type": "boolean",
        "description": "Whether first sentence starts with \"Lorem ipsum...\" (default: true)",
        "default": true
      },
      "asHTML": {
        "type": "boolean",
        "description": "Whether to format output wrapped in <p> HTML tags (default: false)",
        "default": false
      }
    }
  },
  "page": "/"
}

{
  "name": "generate_rsa_keypair",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate RSA public and private key pairs in standard PEM format (512, 1024, 2048, or 4096 bits).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "bits": {
        "type": "number",
        "enum": [
          512,
          1024,
          2048,
          4096
        ],
        "description": "Key length in bits (default: 2048)",
        "default": 2048
      }
    }
  },
  "page": "/"
}

{
  "name": "generate_password",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate cryptographically secure passwords or memorable multi-word passphrases with entropy evaluation, custom formats, and offline crack time estimates.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "format": {
        "type": "string",
        "enum": [
          "passphrase",
          "alphaNumSym",
          "alphaNum",
          "alphaSym",
          "symbols",
          "alphabets",
          "numbers",
          "all"
        ],
        "description": "Password format to generate: \"passphrase\" (memorable words), \"alphaNumSym\" (full mix), \"alphaNum\" (no symbols), \"alphaSym\" (letters & symbols), \"symbols\" (pure symbols), \"alphabets\" (letters only), \"numbers\" (PIN code), or \"all\" (return entire suite of all formats). Default: \"passphrase\".",
        "default": "passphrase"
      },
      "length": {
        "type": "number",
        "description": "Length of generated password (for character-based formats, 4 to 128, default: 16).",
        "default": 16
      },
      "wordCount": {
        "type": "number",
        "description": "Number of words for passphrase format (2 to 10 words, default: 4).",
        "default": 4
      },
      "capitalize": {
        "type": "boolean",
        "description": "Whether to capitalize each word in passphrase format (default: false).",
        "default": false
      },
      "addNumber": {
        "type": "boolean",
        "description": "Whether to append a random 3-digit number to passphrase format (default: false).",
        "default": false
      },
      "addSymbol": {
        "type": "boolean",
        "description": "Whether to append a special symbol to passphrase format (default: false).",
        "default": false
      },
      "excludeAmbiguous": {
        "type": "boolean",
        "description": "Exclude easily confused characters such as 0, O, 1, l, I, | (default: false).",
        "default": false
      },
      "count": {
        "type": "number",
        "description": "Number of passwords to generate (1 to 50, default: 1).",
        "default": 1
      }
    }
  },
  "page": "/"
}

{
  "name": "convert_to_excel_csv",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert CSV text, JSON arrays, or Base64-encoded CSV/Excel files into Windows Excel-compatible CSV with UTF-8 BOM (\\uFEFF) to guarantee 100% Chinese character readability without garbled text.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string",
        "description": "Raw CSV/TSV text to convert into Excel-compatible CSV (with UTF-8 BOM)"
      },
      "data": {
        "type": "array",
        "description": "Array of objects or array of arrays (JSON tabular data) to format as Excel-compatible CSV"
      },
      "base64Content": {
        "type": "string",
        "description": "Optional Base64-encoded CSV, TSV, or XLSX file content"
      },
      "encoding": {
        "type": "string",
        "enum": [
          "auto",
          "utf-8",
          "big5",
          "gb18030",
          "shift_jis",
          "windows-1252"
        ],
        "description": "Source encoding if passing base64Content (default: \"auto\")",
        "default": "auto"
      },
      "includeBom": {
        "type": "boolean",
        "description": "Whether to prepend UTF-8 BOM (\\uFEFF). Default is true to fix Windows Excel Chinese garbled text.",
        "default": true
      },
      "fileName": {
        "type": "string",
        "description": "Export filename (default: \"excel_utf8_bom.csv\")",
        "default": "excel_utf8_bom.csv"
      }
    }
  },
  "page": "/"
}

{
  "name": "convert_docker_run_to_compose",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert a \"docker run\" CLI command into a docker-compose.yml YAML configuration specification.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "dockerRun": {
        "type": "string",
        "description": "The docker run command line string (e.g. \"docker run -d -p 80:80 --name web nginx\")"
      }
    },
    "required": [
      "dockerRun"
    ]
  },
  "page": "/"
}

{
  "name": "convert_data_format",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert data between JSON, YAML, TOML, and XML formats with full bidirectional conversion support.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "content": {
        "type": "string",
        "description": "Input text content in the source format"
      },
      "from": {
        "type": "string",
        "enum": [
          "json",
          "yaml",
          "toml",
          "xml"
        ],
        "description": "Source data format: \"json\", \"yaml\", \"toml\", or \"xml\""
      },
      "to": {
        "type": "string",
        "enum": [
          "json",
          "yaml",
          "toml",
          "xml"
        ],
        "description": "Target data format: \"json\", \"yaml\", \"toml\", or \"xml\""
      },
      "indent": {
        "type": "number",
        "description": "Number of spaces for indentation (where applicable, default 2)",
        "default": 2
      }
    },
    "required": [
      "content",
      "from",
      "to"
    ]
  },
  "page": "/"
}

{
  "name": "parse_crontab_expression",
  "kind": "act",
  "impl": "imperative",
  "description": "Validate and parse a Cron schedule expression into human-readable description.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "expression": {
        "type": "string",
        "description": "Cron expression string (e.g. \"*/15 * * * *\" or \"0 0 1 1 *\")"
      }
    },
    "required": [
      "expression"
    ]
  },
  "page": "/"
}

{
  "name": "parse_phone_number",
  "kind": "act",
  "impl": "imperative",
  "description": "Parse, validate, and format an international phone number (E.164, national, RFC3966) using Google libphonenumber.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "phoneNumber": {
        "type": "string",
        "description": "Phone number string to parse (e.g. \"+886 912 345 678\" or \"0912345678\")"
      },
      "defaultCountry": {
        "type": "string",
        "description": "Default 2-letter ISO country code fallback if number lacks country prefix (e.g. \"TW\", \"US\", \"JP\")",
        "default": "TW"
      }
    },
    "required": [
      "phoneNumber"
    ]
  },
  "page": "/"
}

{
  "name": "validate_iban",
  "kind": "act",
  "impl": "imperative",
  "description": "Validate and parse an International Bank Account Number (IBAN), verifying checksum and extracting country/BBAN details.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "iban": {
        "type": "string",
        "description": "The IBAN string to validate and parse"
      }
    },
    "required": [
      "iban"
    ]
  },
  "page": "/"
}

{
  "name": "calculate_ipv4_subnet",
  "kind": "act",
  "impl": "imperative",
  "description": "Calculate IPv4 subnet properties including network address, netmask, broadcast, host range, CIDR notation, and network size.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "address": {
        "type": "string",
        "description": "IPv4 address with CIDR mask or netmask (e.g. \"192.168.1.1/24\" or \"10.0.0.0 255.255.0.0\")"
      }
    },
    "required": [
      "address"
    ]
  },
  "page": "/"
}

{
  "name": "diff_json",
  "kind": "act",
  "impl": "imperative",
  "description": "Compare two JSON objects or values to produce a detailed tree and list of differences (added, removed, modified).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "original": {
        "type": "string",
        "description": "Original JSON string or data"
      },
      "modified": {
        "type": "string",
        "description": "Modified JSON string or data to compare against original"
      },
      "onlyDifferences": {
        "type": "boolean",
        "description": "Whether to only include modified/added/removed keys (default true)",
        "default": true
      }
    },
    "required": [
      "original",
      "modified"
    ]
  },
  "page": "/"
}

{
  "name": "prettify_sql",
  "kind": "act",
  "impl": "imperative",
  "description": "Format, prettify, and indent SQL queries with customizable dialect and uppercase/lowercase keywords.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": {
        "type": "string",
        "description": "Raw SQL query string to format"
      },
      "dialect": {
        "type": "string",
        "enum": [
          "sql",
          "mysql",
          "postgresql",
          "sqlite",
          "bigquery",
          "mariadb",
          "tsql",
          "plsql",
          "redshift",
          "spark"
        ],
        "description": "SQL dialect (default \"sql\")",
        "default": "sql"
      },
      "keywordCase": {
        "type": "string",
        "enum": [
          "upper",
          "lower",
          "preserve"
        ],
        "description": "Keyword letter casing (default \"upper\")",
        "default": "upper"
      },
      "indent": {
        "type": "number",
        "description": "Number of spaces for indentation (default 2)",
        "default": 2
      }
    },
    "required": [
      "sql"
    ]
  },
  "page": "/"
}

{
  "name": "convert_markdown_to_html",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert Markdown formatted text into clean HTML markup.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "markdown": {
        "type": "string",
        "description": "The Markdown text to convert into HTML"
      },
      "htmlTags": {
        "type": "boolean",
        "description": "Enable HTML tags in source markdown (default false)",
        "default": false
      },
      "linkify": {
        "type": "boolean",
        "description": "Autoconvert URL-like text to links (default true)",
        "default": true
      }
    },
    "required": [
      "markdown"
    ]
  },
  "page": "/"
}

{
  "name": "convert_datetime",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert between Unix timestamps, ISO 8601, ISO 9075, RFC 3339, and RFC 7231 date-time formats.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "input": {
        "type": "string",
        "description": "Input date string, ISO timestamp, or Unix epoch number (seconds or milliseconds). If omitted or \"now\", current time is used.",
        "default": "now"
      }
    }
  },
  "page": "/"
}

{
  "name": "convert_list_format",
  "kind": "act",
  "impl": "imperative",
  "description": "Batch convert and transform lists (lines of items) into formatted strings, comma-separated values, SQL IN lists, or custom prefixed/suffixed items with deduplication and sorting.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "items": {
        "type": "string",
        "description": "Input items separated by newlines or comma"
      },
      "separator": {
        "type": "string",
        "description": "Separator between items (default: \", \")",
        "default": ", "
      },
      "itemPrefix": {
        "type": "string",
        "description": "Prefix added to each item (e.g. \"'\" for SQL strings)",
        "default": ""
      },
      "itemSuffix": {
        "type": "string",
        "description": "Suffix added to each item (e.g. \"'\" for SQL strings)",
        "default": ""
      },
      "listPrefix": {
        "type": "string",
        "description": "Prefix added to whole list (e.g. \"(\" for SQL IN clause)",
        "default": ""
      },
      "listSuffix": {
        "type": "string",
        "description": "Suffix added to whole list (e.g. \")\" for SQL IN clause)",
        "default": ""
      },
      "deduplicate": {
        "type": "boolean",
        "description": "Remove duplicate items (default true)",
        "default": true
      },
      "sort": {
        "type": "string",
        "enum": [
          "none",
          "asc",
          "desc"
        ],
        "description": "Sorting order: \"none\", \"asc\", or \"desc\" (default \"none\")",
        "default": "none"
      },
      "lowerCase": {
        "type": "boolean",
        "description": "Convert items to lowercase (default false)",
        "default": false
      }
    },
    "required": [
      "items"
    ]
  },
  "page": "/"
}

{
  "name": "generate_qr_code",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate a QR code image as an SVG string or Base64 Data URL from text or URL.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Text, URL, or data payload to encode into QR code"
      },
      "format": {
        "type": "string",
        "enum": [
          "dataUrl",
          "svg"
        ],
        "description": "Output format: \"dataUrl\" (PNG image) or \"svg\" (vector SVG text). Default \"dataUrl\".",
        "default": "dataUrl"
      },
      "errorCorrection": {
        "type": "string",
        "enum": [
          "L",
          "M",
          "Q",
          "H"
        ],
        "description": "Error correction level: L (7%), M (15%), Q (25%), H (30%). Default \"M\".",
        "default": "M"
      },
      "width": {
        "type": "number",
        "description": "Width in pixels for PNG dataUrl (default 300)",
        "default": 300
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "generate_hmac",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate Hash-based Message Authentication Code (HMAC) signature using SHA256, SHA512, SHA1, or MD5.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Plaintext message payload to sign"
      },
      "secret": {
        "type": "string",
        "description": "Secret key for HMAC authentication"
      },
      "algorithm": {
        "type": "string",
        "enum": [
          "SHA256",
          "SHA512",
          "SHA1",
          "MD5"
        ],
        "description": "Hashing algorithm (default \"SHA256\")",
        "default": "SHA256"
      },
      "encoding": {
        "type": "string",
        "enum": [
          "hex",
          "base64"
        ],
        "description": "Output encoding (default \"hex\")",
        "default": "hex"
      }
    },
    "required": [
      "text",
      "secret"
    ]
  },
  "page": "/"
}

{
  "name": "bcrypt_tool",
  "kind": "act",
  "impl": "imperative",
  "description": "Hash a plaintext string using bcrypt or verify a plaintext against an existing bcrypt hash.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "hash",
          "verify"
        ],
        "description": "Action to perform: \"hash\" (hash a string) or \"verify\" (compare plaintext with hash)",
        "default": "hash"
      },
      "text": {
        "type": "string",
        "description": "The plaintext password or string"
      },
      "hash": {
        "type": "string",
        "description": "Existing bcrypt hash string to compare against (required when action is \"verify\")"
      },
      "saltRounds": {
        "type": "number",
        "description": "Number of salt rounds for hashing (default 10, between 4 and 16)",
        "default": 10
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "totp_tool",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate or verify 6-digit Time-based One-Time Password (TOTP) codes (RFC 6238) for two-factor authentication, or generate a new Base32 secret.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "generate",
          "verify",
          "generate_secret"
        ],
        "description": "Action: \"generate\" (generate 6-digit OTP from secret), \"verify\" (validate an OTP), or \"generate_secret\" (create new Base32 secret)",
        "default": "generate"
      },
      "secret": {
        "type": "string",
        "description": "Base32 secret key (required for \"generate\" and \"verify\")"
      },
      "token": {
        "type": "string",
        "description": "6-digit OTP code to verify (required when action is \"verify\")"
      },
      "timeStep": {
        "type": "number",
        "description": "Time step in seconds (default 30)",
        "default": 30
      }
    }
  },
  "page": "/"
}

{
  "name": "parse_user_agent",
  "kind": "act",
  "impl": "imperative",
  "description": "Parse browser User-Agent header string to extract detailed browser, OS, engine, CPU, and device information.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "userAgent": {
        "type": "string",
        "description": "The User-Agent string to parse"
      }
    },
    "required": [
      "userAgent"
    ]
  },
  "page": "/"
}

{
  "name": "lookup_http_status",
  "kind": "answer",
  "impl": "imperative",
  "description": "Lookup HTTP status code standard definitions, messages, and official descriptions by numeric code or keyword.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "HTTP status code number (e.g. 404, 200) or name keyword (e.g. \"not found\", \"unauthorized\", \"teapot\")"
      }
    },
    "required": [
      "query"
    ]
  },
  "page": "/"
}

{
  "name": "analyze_text_statistics",
  "kind": "act",
  "impl": "imperative",
  "description": "Compute comprehensive statistics on a text string including character count, word count, line count, byte size, Chinese/CJK character count, and estimated reading time.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Input text string to analyze"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}

{
  "name": "convert_color",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert colors between HEX, RGB, HSL, and CMYK color models with luminance, accessibility contrast, and color naming.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "color": {
        "type": "string",
        "description": "Input color in any valid CSS format (e.g. \"#3498db\", \"rgb(52, 152, 219)\", \"hsl(204, 70%, 53%)\", \"dodgerblue\")"
      }
    },
    "required": [
      "color"
    ]
  },
  "page": "/"
}

{
  "name": "html_entities_codec",
  "kind": "act",
  "impl": "imperative",
  "description": "Escape or unescape HTML special character entities (&, <, >, \", ').",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "Input text to escape or unescape"
      },
      "action": {
        "type": "string",
        "enum": [
          "escape",
          "unescape"
        ],
        "description": "Action: \"escape\" (convert characters to entities) or \"unescape\" (convert entities back to characters). Default \"escape\".",
        "default": "escape"
      }
    },
    "required": [
      "text"
    ]
  },
  "page": "/"
}