ToolAPI

Validate JSON text; return parsed object or error.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Pretty-print JSON with indent. When: Pretty-print JSON when the agent needs readable output.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "indent": {
      "type": "integer",
      "default": 2
    }
  },
  "required": [
    "text"
  ]
}

Minify JSON (remove whitespace). When: Minify JSON for compact payloads or size checks.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert CSV text to JSON array of row objects. When: Convert CSV rows → JSON array of objects.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert JSON array of objects to CSV text.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate YAML text; return parsed object or error.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse YAML and return JSON-compatible object.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert JSON text to YAML string. When: Convert JSON → YAML for config files agents write.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate XML markup (well-formed check).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Pretty-print XML with indentation. When: Pretty-print XML after the agent edits markup.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Query JSON with JSONPath expression; returns matching values.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "JSON text"
    },
    "path": {
      "type": "string",
      "description": "e.g. $.store.book[*].author"
    }
  },
  "required": [
    "text",
    "path"
  ]
}

Deep-merge two JSON objects (second overlays first).

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

Flatten nested JSON to dot-key map. When: Flatten nested JSON keys before comparing or exporting.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "separator": {
      "type": "string",
      "default": "."
    }
  },
  "required": [
    "text"
  ]
}

Unified diff of two JSON documents (pretty-printed).

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

Recursively sort JSON object keys. When: Canonicalize JSON key order for stable diffs/hashes.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Summarize JSON value types (counts per type in tree).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate JSON data against JSON Schema (Draft 7).

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string",
      "description": "JSON document text"
    },
    "schema": {
      "type": "string",
      "description": "JSON Schema (Draft 7)"
    },
    "max_errors": {
      "type": "integer",
      "default": 20,
      "minimum": 1,
      "maximum": 50
    }
  },
  "required": [
    "data",
    "schema"
  ]
}

Validate TOML text; return parsed object or error.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse TOML and return JSON-compatible object.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert JSON object text to TOML string.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate TOML config against JSON Schema (Draft 7) in one step.

{
  "type": "object",
  "properties": {
    "toml": {
      "type": "string",
      "description": "TOML document text"
    },
    "schema": {
      "type": "string",
      "description": "JSON Schema (Draft 7)"
    },
    "max_errors": {
      "type": "integer",
      "default": 20,
      "minimum": 1,
      "maximum": 50
    }
  },
  "required": [
    "toml",
    "schema"
  ]
}

Format SQL text (never executed; reindent + keyword case).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "keyword_case": {
      "type": "string",
      "enum": [
        "upper",
        "lower",
        "capitalize"
      ],
      "default": "upper"
    },
    "reindent": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "text"
  ]
}

Validate GraphQL query or schema SDL syntax (parse only).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate OpenAPI 3.x document (JSON or YAML snippet).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Compare two OpenAPI specs and flag breaking vs non-breaking API changes.

{
  "type": "object",
  "properties": {
    "old": {
      "type": "string",
      "description": "Previous OpenAPI JSON/YAML"
    },
    "new": {
      "type": "string",
      "description": "New OpenAPI JSON/YAML"
    }
  },
  "required": [
    "old",
    "new"
  ]
}

Audit package.json or pyproject.toml — license, risky scripts, loose ranges; emit semver_checks for batch. Note: best-effort / heuristic — not a full language parser.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Manifest file contents"
    },
    "kind": {
      "type": "string",
      "enum": [
        "auto",
        "npm",
        "pyproject"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}

Diff two GraphQL schemas for removed types/fields (breaking changes).

{
  "type": "object",
  "properties": {
    "old": {
      "type": "string"
    },
    "new": {
      "type": "string"
    }
  },
  "required": [
    "old",
    "new"
  ]
}

Validate docker-compose YAML and flag privileged/host-network/secret env issues.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Lint GitHub Actions workflow YAML (triggers, unpinned actions, curl|bash).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Audit Python requirements.txt for unpinned/VCS/deprecated packages.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Batch JSON Schema (Draft 7) validation — up to 25 documents (agent favorite).

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "maxItems": 25,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "schema": {
            "type": "string"
          }
        },
        "required": [
          "data",
          "schema"
        ]
      }
    },
    "max_errors": {
      "type": "integer",
      "default": 10
    }
  },
  "required": [
    "items"
  ]
}

Assert JSONPath expressions against JSON (exists/equals/type) — agent self-check.

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "assertions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "exists": {
            "type": "boolean"
          },
          "equals": {},
          "type": {
            "type": "string"
          }
        },
        "required": [
          "path"
        ]
      }
    }
  },
  "required": [
    "data",
    "assertions"
  ]
}

Deep-compare two JSON documents and list differing paths.

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

Parse YAML then validate against JSON Schema (Draft 7).

{
  "type": "object",
  "properties": {
    "yaml": {
      "type": "string"
    },
    "schema": {
      "type": "string"
    },
    "max_errors": {
      "type": "integer",
      "default": 20
    }
  },
  "required": [
    "yaml",
    "schema"
  ]
}

Lint tsconfig.json structure (compilerOptions, strict hints).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Get value by RFC 6901 JSON Pointer (e.g. /user/id). When: Read one field by RFC 6901 pointer without full walk in the agent.

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "pointer": {
      "type": "string",
      "default": ""
    }
  },
  "required": [
    "data"
  ]
}

Apply RFC 6902 JSON Patch ops (add/remove/replace/test/move/copy). When: Apply RFC 6902 ops (add/remove/replace/test/move/copy).

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "patch": {
      "type": "string"
    }
  },
  "required": [
    "data",
    "patch"
  ]
}

Infer a Draft-7 JSON Schema from a sample JSON document (agent favorite).

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "title": {
      "type": "string",
      "default": "Inferred"
    }
  },
  "required": [
    "data"
  ]
}

Validate JSON Lines (NDJSON); optional per-line JSON Schema. When: Validate NDJSON / JSON Lines logs or datasets.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "schema": {
      "type": "string"
    },
    "max_lines": {
      "type": "integer",
      "default": 200
    }
  },
  "required": [
    "text"
  ]
}

Convert XML document to JSON (attributes as @attr). When: Convert XML → JSON for agents that prefer JSON tools.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Apply RFC 7396 JSON Merge Patch (null deletes keys). When: RFC 7396 merge patch — use when patching JSON configs.

{
  "type": "object",
  "properties": {
    "target": {
      "type": "string"
    },
    "patch": {
      "type": "string"
    }
  },
  "required": [
    "target",
    "patch"
  ]
}

Validate CSV structure — consistent column counts / header. When: Check CSV column consistency before import.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "delimiter": {
      "type": "string",
      "default": ","
    },
    "has_header": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "text"
  ]
}

Parse INI / simple key=value config into sections. When: Parse INI/section configs into structured maps.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

List OpenAPI path operations (method, path, operationId, tags). When: List OpenAPI operations before validate/diff.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

List GraphQL query/mutation/subscription names and type defs. When: List GraphQL ops/types from a document (best-effort).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse Java .properties key=value file. When: Parse Java .properties key=value configs (best-effort).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Current UTC unix timestamp and ISO-8601.

{
  "type": "object",
  "properties": {}
}

Convert unix seconds or ISO-8601 to both formats.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}

Convert datetime between IANA timezones (e.g. UTC to Asia/Shanghai).

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string",
      "description": "Unix seconds or ISO datetime"
    },
    "from_timezone": {
      "type": "string",
      "default": "UTC"
    },
    "to_timezone": {
      "type": "string",
      "description": "e.g. Asia/Shanghai"
    }
  },
  "required": [
    "value",
    "to_timezone"
  ]
}

List common IANA timezone names for conversion.

{
  "type": "object",
  "properties": {}
}

Parse unix timestamp or ISO-8601 into UTC ISO + unix.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}

Parse duration (ISO-8601 PnDTnHnMnS or human 1h30m / 90s) to seconds. When: Parse ISO-8601 / human durations to seconds.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}

Test regex pattern; returns match, groups, span.

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "flags": {
      "type": "string",
      "description": "i, m, s"
    }
  },
  "required": [
    "pattern",
    "text"
  ]
}

Replace regex matches in text (supports backreferences in replacement).

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string"
    },
    "replacement": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "flags": {
      "type": "string",
      "description": "i, m, s"
    },
    "global_replace": {
      "type": "boolean",
      "default": true
    },
    "count": {
      "type": "integer",
      "description": "Max replacements when global",
      "default": 0
    }
  },
  "required": [
    "pattern",
    "replacement",
    "text"
  ]
}

Unified line diff between two texts (like git diff).

{
  "type": "object",
  "properties": {
    "left": {
      "type": "string"
    },
    "right": {
      "type": "string"
    }
  },
  "required": [
    "left",
    "right"
  ]
}

URL-safe slug from title or heading. When: Make URL-safe slugs from titles/filenames.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Count chars, words, lines, sentences; estimate reading time.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert case: lower, upper, title, snake, kebab, camel, pascal.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "mode": {
      "type": "string",
      "enum": [
        "lower",
        "upper",
        "title",
        "snake",
        "kebab",
        "camel",
        "pascal"
      ]
    }
  },
  "required": [
    "text",
    "mode"
  ]
}

Generate lorem ipsum placeholder paragraphs.

{
  "type": "object",
  "properties": {
    "paragraphs": {
      "type": "integer",
      "default": 1,
      "minimum": 1,
      "maximum": 10
    }
  }
}

Convert color between hex, rgb(), and hsl().

{
  "type": "object",
  "properties": {
    "color": {
      "type": "string",
      "description": "hex, rgb(), or hsl()"
    },
    "to_format": {
      "type": "string",
      "enum": [
        "all",
        "hex",
        "rgb",
        "hsl"
      ],
      "default": "all"
    }
  },
  "required": [
    "color"
  ]
}

Convert units: length, weight, temperature, data, speed, time.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "number"
    },
    "from_unit": {
      "type": "string"
    },
    "to_unit": {
      "type": "string"
    },
    "category": {
      "type": "string",
      "description": "optional: length, weight, temperature, data, speed, time"
    }
  },
  "required": [
    "value",
    "from_unit",
    "to_unit"
  ]
}

List supported units per category for unit_convert.

{
  "type": "object",
  "properties": {}
}

Convert Markdown text to HTML. When: Render markdown → HTML for previews or emails.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Convert HTML to Markdown text. When: Convert HTML → markdown for docs the agent edits.

{
  "type": "object",
  "properties": {
    "html": {
      "type": "string"
    }
  },
  "required": [
    "html"
  ]
}

Pick one item from a list (optional seed for reproducibility).

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array"
    },
    "seed": {
      "type": "integer",
      "description": "Optional RNG seed"
    }
  },
  "required": [
    "items"
  ]
}

Truncate text with ellipsis. When: Truncate long strings with ellipsis for UI/logs.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "max_length": {
      "type": "integer",
      "default": 80
    },
    "ellipsis": {
      "type": "string",
      "default": "..."
    }
  },
  "required": [
    "text"
  ]
}

Extract HTTP/HTTPS URLs from arbitrary text.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Extract email addresses from text. When: Pull email addresses from free text / logs.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate email address format. When: Syntax-check a single email address.

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string"
    }
  },
  "required": [
    "email"
  ]
}

Wrap text to a maximum line width. When: Hard-wrap text to a column width.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "width": {
      "type": "integer",
      "default": 80
    }
  },
  "required": [
    "text"
  ]
}

Deduplicate list items preserving order.

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array"
    }
  },
  "required": [
    "items"
  ]
}

Fill {{variable}} placeholders in a template string.

{
  "type": "object",
  "properties": {
    "template": {
      "type": "string"
    },
    "variables": {
      "type": "object"
    }
  },
  "required": [
    "template",
    "variables"
  ]
}

Unicode normalization (NFC/NFD/NFKC/NFKD).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "form": {
      "type": "string",
      "enum": [
        "NFC",
        "NFD",
        "NFKC",
        "NFKD"
      ],
      "default": "NFC"
    }
  },
  "required": [
    "text"
  ]
}

Parse User-Agent string into browser, OS, and device hints.

{
  "type": "object",
  "properties": {
    "user_agent": {
      "type": "string"
    }
  },
  "required": [
    "user_agent"
  ]
}

Scan text for hardcoded secrets (API keys, tokens, private keys). Returns redacted findings.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "min_entropy": {
      "type": "number",
      "default": 3.5,
      "description": "Entropy threshold for heuristic strings"
    }
  },
  "required": [
    "text"
  ]
}

Lint Dockerfile for common security/style issues (root user, curl|sh, secrets).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Check .env text contains required keys (and non-empty values).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "required": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "text",
    "required"
  ]
}

Check filesystem path for traversal / absolute / sensitive system paths.

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string"
    },
    "allow_absolute": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "path"
  ]
}

Validate SPDX license expression against common license IDs.

{
  "type": "object",
  "properties": {
    "expression": {
      "type": "string"
    }
  },
  "required": [
    "expression"
  ]
}

Validate robots.txt syntax and User-agent rules.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse Content-Security-Policy header and flag unsafe directives.

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}

Check CORS Allow-Origin vs credentials for unsafe combinations.

{
  "type": "object",
  "properties": {
    "origin": {
      "type": "string"
    },
    "allow_origin": {
      "type": "string"
    },
    "allow_credentials": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "allow_origin"
  ]
}

Extract markdown/bare links and flag javascript: URLs.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Review .gitignore for common missing ignores (.env, node_modules, keys).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Validate .editorconfig syntax and common keys.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Lint nginx config snippets (braces, SSLv3, server_tokens, HSTS hints).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Scan SQL text for dangerous patterns (DROP/TRUNCATE/DELETE without WHERE). Note: best-effort / heuristic — not a full language parser.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Scan HTML for XSS-prone patterns (javascript: URLs, inline handlers, eval). Note: best-effort / heuristic — not a full language parser.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Lint Conventional Commits message (feat/fix/chore…).

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    }
  },
  "required": [
    "message"
  ]
}

Parse Keep-a-Changelog style markdown into version sections.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Extract TODO/FIXME/HACK/XXX comments with line numbers.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Extract fenced code blocks from markdown (language + code).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse unified diff — files changed, lines added/removed.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Match paths against glob patterns (gitignore-style fnmatch).

{
  "type": "object",
  "properties": {
    "paths": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "patterns": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "paths",
    "patterns"
  ]
}

Validate identifier for python/javascript/typescript (keywords + syntax).

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "language": {
      "type": "string",
      "enum": [
        "python",
        "javascript",
        "typescript"
      ],
      "default": "python"
    }
  },
  "required": [
    "name"
  ]
}

SequenceMatcher similarity ratio between two texts.

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

List imports from python/js source and flag duplicates. Note: best-effort / heuristic — not a full language parser.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "language": {
      "type": "string",
      "enum": [
        "python",
        "javascript"
      ],
      "default": "python"
    }
  },
  "required": [
    "text"
  ]
}

Parse YAML frontmatter from markdown (--- ... ---). When: Split YAML frontmatter from markdown body.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Build a table of contents from markdown headings. When: Build heading TOC from markdown docs.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "max_level": {
      "type": "integer",
      "default": 3,
      "minimum": 1,
      "maximum": 6
    }
  },
  "required": [
    "text"
  ]
}

Match paths against .gitignore rules (ignore / negate). When: Test paths against .gitignore rules (best-effort).

{
  "type": "object",
  "properties": {
    "paths": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "gitignore": {
      "type": "string"
    }
  },
  "required": [
    "paths",
    "gitignore"
  ]
}

Shell-escape a string for posix/powershell/cmd (safe quoting). When: Safely quote strings for posix/powershell/cmd.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "shell": {
      "type": "string",
      "enum": [
        "posix",
        "powershell",
        "cmd"
      ],
      "default": "posix"
    }
  },
  "required": [
    "text"
  ]
}

Normalize filesystem path (resolve . and ..) for posix or windows. When: Resolve . and .. in filesystem paths.

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string"
    },
    "style": {
      "type": "string",
      "enum": [
        "posix",
        "windows"
      ],
      "default": "posix"
    }
  },
  "required": [
    "path"
  ]
}

Diff two .env files — only_in_a / only_in_b / changed values. When: Diff two .env files for missing/changed keys.

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

List scripts from package.json or pyproject.toml (poetry/PEP 621). When: List npm/poetry/PEP 621 scripts from manifests.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "kind": {
      "type": "string",
      "enum": [
        "auto",
        "npm",
        "pyproject"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}

Detect and normalize line endings to lf/crlf/cr. When: Detect/normalize CRLF vs LF.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "style": {
      "type": "string",
      "enum": [
        "lf",
        "crlf",
        "cr"
      ],
      "default": "lf"
    }
  },
  "required": [
    "text"
  ]
}

Parse #! shebang line — interpreter and args. When: Parse #! interpreter lines in scripts.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Scan text for trailing whitespace and tab characters. Note: best-effort / heuristic — not a full language parser.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Extract table names from SQL (FROM/JOIN/INTO/UPDATE/TABLE). When: Heuristic extract of SQL table names (best-effort).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Extract name@version from requirements/lockfile/go.mod/Cargo snippets. When: Extract name@version from lock/requirements snippets (best-effort).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "ecosystem": {
      "type": "string",
      "enum": [
        "auto",
        "pip",
        "npm",
        "go",
        "cargo"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}

WCAG contrast ratio between two hex colors (AA/AAA). When: WCAG contrast ratio for UI color pairs.

{
  "type": "object",
  "properties": {
    "fg": {
      "type": "string"
    },
    "bg": {
      "type": "string"
    }
  },
  "required": [
    "fg",
    "bg"
  ]
}

Format bytes to human size, or parse '1.5 GB' to bytes. When: Format or parse human byte sizes (1.5 GB).

{
  "type": "object",
  "properties": {
    "value": {
      "type": "number"
    },
    "text": {
      "type": "string"
    },
    "precision": {
      "type": "integer",
      "default": 2
    }
  }
}

Offline password strength heuristic (length/classes/common). When: Offline password strength heuristic (not a cracker).

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    }
  },
  "required": [
    "password"
  ]
}

Parse /etc/hosts style file into IP → hostnames entries. When: Parse /etc/hosts style IP→hostname maps.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

MD5 hex digest of UTF-8 text. When: MD5 digest (non-crypto integrity / legacy checksums).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

SHA256 hex digest.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

SHA512 hex digest.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Base64-encode UTF-8.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Base64-decode to UTF-8.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Base64url-encode UTF-8 (no padding, URL-safe).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Base64url-decode to UTF-8.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Percent-encode URL component.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Decode percent-encoded string.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Escape HTML entities.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Unescape HTML entities.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

UTF-8 text to hex string.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Hex string to UTF-8 text.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Generate UUID v1/v3/v4/v5 (batch supported). v3/v5 need name + namespace.

{
  "type": "object",
  "properties": {
    "version": {
      "type": "integer",
      "enum": [
        1,
        3,
        4,
        5
      ],
      "default": 4
    },
    "count": {
      "type": "integer",
      "default": 1,
      "minimum": 1,
      "maximum": 20
    },
    "name": {
      "type": "string",
      "description": "Required for v3/v5"
    },
    "namespace": {
      "type": "string",
      "description": "UUID string for v3/v5 namespace"
    },
    "namespace_type": {
      "type": "string",
      "enum": [
        "dns",
        "url",
        "oid",
        "x500"
      ]
    }
  }
}

Parse UUID string: version, variant, hex bytes.

{
  "type": "object",
  "properties": {
    "uuid": {
      "type": "string"
    }
  },
  "required": [
    "uuid"
  ]
}

Generate URL-friendly nanoid (like npm nanoid).

{
  "type": "object",
  "properties": {
    "size": {
      "type": "integer",
      "default": 21,
      "minimum": 1,
      "maximum": 64
    }
  }
}

Cryptographically secure random password.

{
  "type": "object",
  "properties": {
    "length": {
      "type": "integer",
      "default": 16,
      "minimum": 8,
      "maximum": 64
    },
    "symbols": {
      "type": "boolean",
      "default": true
    }
  }
}

Decode JWT payload and header (no signature verification).

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}

Verify JWT signature (HS* with secret, RS* with public_key PEM).

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    },
    "secret": {
      "type": "string",
      "description": "For HS256/384/512"
    },
    "public_key": {
      "type": "string",
      "description": "PEM public key for RS algorithms"
    },
    "algorithms": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "e.g. [\"HS256\"]"
    }
  },
  "required": [
    "token"
  ]
}

Sign JWT payload (HS* with secret, RS* with private_key PEM).

{
  "type": "object",
  "properties": {
    "payload": {
      "type": "object",
      "description": "Claims object or JSON string"
    },
    "secret": {
      "type": "string"
    },
    "private_key": {
      "type": "string",
      "description": "PEM private key for RS algorithms"
    },
    "algorithm": {
      "type": "string",
      "default": "HS256"
    },
    "header": {
      "type": "object",
      "description": "Optional extra JWT header fields"
    }
  },
  "required": [
    "payload"
  ]
}

HMAC sign message (sha1/sha256/sha512); hex or base64 output.

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    },
    "secret": {
      "type": "string"
    },
    "algorithm": {
      "type": "string",
      "default": "sha256"
    },
    "encoding": {
      "type": "string",
      "enum": [
        "hex",
        "base64"
      ],
      "default": "hex"
    }
  },
  "required": [
    "message",
    "secret"
  ]
}

Verify HMAC signature (hex or base64).

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    },
    "secret": {
      "type": "string"
    },
    "signature": {
      "type": "string"
    },
    "algorithm": {
      "type": "string",
      "default": "sha256"
    }
  },
  "required": [
    "message",
    "secret",
    "signature"
  ]
}

Bcrypt-hash a password for storage.

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    },
    "rounds": {
      "type": "integer",
      "default": 12,
      "minimum": 4,
      "maximum": 15
    }
  },
  "required": [
    "password"
  ]
}

Verify password against bcrypt hash.

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    },
    "hash": {
      "type": "string"
    }
  },
  "required": [
    "password",
    "hash"
  ]
}

Convert number between bases 2-36 (binary, octal, decimal, hex).

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    },
    "from_base": {
      "type": "string",
      "description": "2-36 or binary/octal/decimal/hex"
    },
    "to_base": {
      "type": "string"
    }
  },
  "required": [
    "value",
    "from_base",
    "to_base"
  ]
}

Generate QR code as SVG (base64 data URI included).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "border": {
      "type": "integer",
      "default": 4,
      "minimum": 1,
      "maximum": 10
    }
  },
  "required": [
    "text"
  ]
}

Random integer in inclusive range (optional seed).

{
  "type": "object",
  "properties": {
    "min_val": {
      "type": "integer"
    },
    "max_val": {
      "type": "integer"
    },
    "seed": {
      "type": "integer"
    }
  },
  "required": [
    "min_val",
    "max_val"
  ]
}

Random string (alphanumeric, hex, base64 charset or custom).

{
  "type": "object",
  "properties": {
    "length": {
      "type": "integer",
      "default": 16
    },
    "charset": {
      "type": "string",
      "default": "alphanumeric"
    },
    "seed": {
      "type": "integer"
    }
  }
}

Compare two hash digests (case-insensitive).

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

Decode JWT header/claims (no verify) and flag alg=none, missing exp, privileged roles.

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}

Remote desktop tools comparison JSON for AI citation.

{
  "type": "object",
  "properties": {}
}

Parse URL into scheme, host, path, query components.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}

Explain HTTP status code (e.g. 404, 429, 503).

{
  "type": "object",
  "properties": {
    "code": {
      "type": "integer"
    }
  },
  "required": [
    "code"
  ]
}

Parse semver string into major, minor, patch, prerelease.

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    }
  },
  "required": [
    "version"
  ]
}

Compare two semver strings (less / equal / greater).

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}

Check if version satisfies npm-style range (^ ~ >= <= > <).

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    },
    "range": {
      "type": "string"
    }
  },
  "required": [
    "version",
    "range"
  ]
}

Batch semver range checks for dependency audits (max 50).

{
  "type": "object",
  "properties": {
    "checks": {
      "type": "array",
      "maxItems": 50,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "version": {
            "type": "string"
          },
          "range": {
            "type": "string"
          }
        },
        "required": [
          "version",
          "range"
        ]
      }
    }
  },
  "required": [
    "checks"
  ]
}

Heuristic check whether two semver ranges share any sample versions (conflict hint).

{
  "type": "object",
  "properties": {
    "range_a": {
      "type": "string"
    },
    "range_b": {
      "type": "string"
    },
    "samples": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "range_a",
    "range_b"
  ]
}

Sort a list of semver versions ascending or descending. When: Sort semver lists before picking latest/oldest.

{
  "type": "object",
  "properties": {
    "versions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "reverse": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "versions"
  ]
}

Pick the highest version that satisfies a semver range (npm-style).

{
  "type": "object",
  "properties": {
    "versions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "range": {
      "type": "string"
    }
  },
  "required": [
    "versions",
    "range"
  ]
}

Bump a semver version by major/minor/patch. When: Bump major/minor/patch when cutting a release.

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    },
    "release": {
      "type": "string",
      "enum": [
        "major",
        "minor",
        "patch"
      ],
      "default": "patch"
    }
  },
  "required": [
    "version"
  ]
}

Calculate IPv4/IPv6 network info from CIDR (hosts, broadcast, private).

{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string",
      "description": "e.g. 192.168.1.0/24"
    }
  },
  "required": [
    "cidr"
  ]
}

Check if IP address falls within a CIDR range.

{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string"
    },
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "cidr",
    "ip"
  ]
}

Geolocate public IP: country, city, lat/lon, timezone, ISP.

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}

Parse .env / dotenv text into key-value variables.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

List PEM blocks in text (label, DER size, SHA256 fingerprint).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Parse X.509 certificate PEM: subject, issuer, validity, SAN, fingerprint.

{
  "type": "object",
  "properties": {
    "pem": {
      "type": "string"
    }
  },
  "required": [
    "pem"
  ]
}

DNS lookup for domain (A, AAAA, MX, TXT, NS, CNAME, SOA).

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    },
    "record_type": {
      "type": "string",
      "enum": [
        "A",
        "AAAA",
        "MX",
        "TXT",
        "NS",
        "CNAME",
        "SOA",
        "ANY"
      ],
      "default": "A"
    }
  },
  "required": [
    "domain"
  ]
}

Domain registration lookup via RDAP (registrar, dates, nameservers).

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}

Fetch live TLS certificate from host:port (expiry, issuer, SAN).

{
  "type": "object",
  "properties": {
    "host": {
      "type": "string"
    },
    "port": {
      "type": "integer",
      "default": 443,
      "minimum": 1,
      "maximum": 65535
    }
  },
  "required": [
    "host"
  ]
}

Reverse DNS (PTR) lookup for IP address.

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}

TCP port open/closed check with latency ms.

{
  "type": "object",
  "properties": {
    "host": {
      "type": "string"
    },
    "port": {
      "type": "integer",
      "minimum": 1,
      "maximum": 65535
    }
  },
  "required": [
    "host",
    "port"
  ]
}

Fetch HTTP response headers (HEAD/GET) for URL.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "method": {
      "type": "string",
      "enum": [
        "HEAD",
        "GET"
      ],
      "default": "HEAD"
    },
    "follow_redirects": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "url"
  ]
}

List supported fiat currencies (Frankfurter/ECB, no API key).

{
  "type": "object",
  "properties": {}
}

Latest exchange rates (Frankfurter ECB data, no API key).

{
  "type": "object",
  "properties": {
    "base": {
      "type": "string",
      "default": "USD"
    },
    "symbols": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional target currencies e.g. CNY, EUR"
    }
  }
}

Convert amount between currencies using latest ECB rates.

{
  "type": "object",
  "properties": {
    "amount": {
      "type": "number"
    },
    "from_currency": {
      "type": "string"
    },
    "to_currency": {
      "type": "string"
    }
  },
  "required": [
    "amount",
    "from_currency",
    "to_currency"
  ]
}

Check URL for SSRF risk (localhost, private IP, metadata hosts).

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}

Classify IP as private/loopback/link-local/global (SSRF helper).

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}

Normalize URL (lowercase host, sort query, drop fragment).

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "sort_query": {
      "type": "boolean",
      "default": true
    },
    "drop_fragment": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "url"
  ]
}

Parse Content-Type header into mime/charset/params.

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}

Classify HTTP status codes into 2xx/3xx/4xx/5xx buckets.

{
  "type": "object",
  "properties": {
    "codes": {
      "type": "array",
      "items": {
        "type": [
          "integer",
          "string"
        ]
      }
    }
  },
  "required": [
    "codes"
  ]
}

Parse URL query string into key/value map (supports multi-values). When: Parse URL query strings into maps.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string"
    }
  },
  "required": [
    "query"
  ]
}

Build URL query string from params object. When: Build query strings from param objects.

{
  "type": "object",
  "properties": {
    "params": {
      "type": "object"
    },
    "doseq": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "params"
  ]
}

Parse Cookie request header into name/value map. When: Parse Cookie request headers.

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}

Lookup MIME type by file extension/path, or extensions by MIME. When: Map file extension ↔ MIME type.

{
  "type": "object",
  "properties": {
    "path_or_ext": {
      "type": "string"
    },
    "mime": {
      "type": "string"
    }
  }
}

Join base URL with relative path (urllib urljoin). When: Join base URL + relative path correctly.

{
  "type": "object",
  "properties": {
    "base": {
      "type": "string"
    },
    "path": {
      "type": "string"
    }
  },
  "required": [
    "base",
    "path"
  ]
}

Parse domain into labels, TLD, registrable domain, subdomain. When: Split domain into subdomain/registrable/TLD (best-effort eTLD).

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}

Parse git remote URL (ssh/https) into host/owner/repo. When: Parse git@ / https remotes into owner/repo.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}

Parse raw HTTP request/response header block into map. When: Parse raw HTTP header blocks.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}

Detect IPv4/IPv6 and classify private/loopback/global. When: Classify IPv4/IPv6 and private/global.

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}

Parse 5-field cron into named fields (minute hour dom month dow).

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}

Check cron string has exactly five fields.

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}

Validate cron field syntax and value ranges (minute 0-59, hour 0-23, etc.).

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}

Preview next N execution times for a 5-field cron expression.

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    },
    "count": {
      "type": "integer",
      "default": 5,
      "minimum": 1,
      "maximum": 20
    },
    "from_time": {
      "type": "string",
      "description": "Optional unix or ISO start time"
    },
    "timezone": {
      "type": "string",
      "default": "UTC"
    }
  },
  "required": [
    "expr"
  ]
}

Human-readable natural language description of cron expression (EN + ZH).

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}

Check if a cron expression matches a specific datetime (ISO-8601).

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    },
    "at_time": {
      "type": "string",
      "description": "ISO-8601 datetime"
    },
    "timezone": {
      "type": "string",
      "default": "UTC"
    }
  },
  "required": [
    "expr",
    "at_time"
  ]
}

Batch semantic validate of 5-field cron expressions.

{
  "type": "object",
  "properties": {
    "expressions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 30
    }
  },
  "required": [
    "expressions"
  ]
}

Create disposable receive-only inbox @mail.toolapi.org (24h TTL). Returns address + secret token.

{
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string",
      "description": "Optional local-part prefix (alphanumeric)"
    }
  }
}

List messages in a temp inbox (requires token from mail_inbox_create).

{
  "type": "object",
  "properties": {
    "inbox_id": {
      "type": "string"
    },
    "address": {
      "type": "string"
    },
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}

Read full message body from temp inbox.

{
  "type": "object",
  "properties": {
    "message_id": {
      "type": "string"
    },
    "inbox_id": {
      "type": "string"
    },
    "address": {
      "type": "string"
    },
    "token": {
      "type": "string"
    }
  },
  "required": [
    "message_id",
    "token"
  ]
}