QuassLabs API

Run an AI system prompt (and optional agent config) through a 45-criterion alignment/safety rubric. Returns a letter grade (A-F), numeric score, per-flag remediation, and a pass/fail verdict.

{
  "type": "object",
  "properties": {
    "system_prompt": {
      "type": "string",
      "description": "The system prompt text to evaluate."
    },
    "agent_config": {
      "type": "object",
      "description": "Optional agent config (tools, memory, temperature, etc.)."
    },
    "model_id": {
      "type": "string",
      "description": "Optional target model identifier."
    }
  },
  "required": [
    "system_prompt"
  ]
}

Look up Bureau of Land Management land status for a US coordinate: BLM ownership, jurisdiction, allowed activities (rockhounding, camping), permit requirements, and special designations (ACEC, Wilderness, WSA, NM/NCA).

{
  "type": "object",
  "properties": {
    "lat": {
      "type": "number",
      "description": "Latitude, -90 to 90."
    },
    "lon": {
      "type": "number",
      "description": "Longitude, -180 to 180."
    },
    "radius_km": {
      "type": "number",
      "description": "Optional buffer radius in km (0-50, default 1.0)."
    }
  },
  "required": [
    "lat",
    "lon"
  ]
}

Diagram quality QA. Catch and fix the things that ruin diagrams: (1) unreadable label contrast - POST a mermaid/SVG or HTML diagram, get every WCAG-AA failure (incl. mermaid <style>-block label colors, with unresolvable fills flagged honestly, not false-passed) + auto-corrected colors; (2) harden a mermaid SOURCE before it renders - rewrites every fill/label pair and remaps fills no label color can rescue, which scanning cannot do because a per-node style line overrides the theme block; (3) HTML-looks-fine-but-prints-broken - checks for the print-color-adjust/page-break gotchas and returns the fix CSS; (4) arrows crossing objects - returns the ELK-renderer config + layout rules that minimize crossings. Pure deterministic - no AI, no rate limit.

{
  "type": "object",
  "properties": {
    "mode": {
      "type": "string",
      "enum": [
        "scan",
        "harden",
        "contrast",
        "readable",
        "palette",
        "print",
        "layout"
      ],
      "description": "Default \"scan\". scan=check rendered output; harden=fix a mermaid source before rendering; print=print-safety check; layout=arrow-crossing reduction."
    },
    "content": {
      "type": "string",
      "description": "scan/print: the SVG or HTML diagram/document source."
    },
    "source": {
      "type": "string",
      "description": "harden: the mermaid SOURCE text (not rendered SVG)."
    },
    "format": {
      "type": "string",
      "enum": [
        "svg",
        "html"
      ],
      "description": "scan: content format (default svg)."
    },
    "autofix": {
      "type": "boolean",
      "description": "scan: include suggested corrected colors."
    },
    "add_init": {
      "type": "boolean",
      "description": "harden: prepend the %%{init}%% theme block (default true)."
    },
    "fg": {
      "type": "string",
      "description": "contrast: foreground hex (#rrggbb)."
    },
    "bg": {
      "type": "string",
      "description": "contrast/readable: background/fill hex (#rrggbb)."
    },
    "large": {
      "type": "boolean",
      "description": "contrast/harden: use the 3:1 large-text threshold."
    },
    "brand": {
      "type": "string",
      "description": "brand palette to use (e.g. appstango). Default from config."
    },
    "renderer": {
      "type": "string",
      "description": "layout: mermaid renderer (default \"elk\")."
    }
  }
}

Detect AI-writing tells in text. POST prose and get a 0-1 ai_ness score + band (low/medium/high) + the EXACT patterns that fired (AI vocabulary, significance inflation, promotional language, filler phrases, negative parallelism, rule-of-three, em-dash overuse) with sample spans. Explainable, not an opaque classifier - every point is a named, located pattern. Deterministic, no LLM. The rewrite is a separate step.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The prose to score (up to 100k chars)."
    }
  },
  "required": [
    "text"
  ]
}

SaaS health advisor. POST your MRR/customers (+ optional churn/CAC/margin/growth) and get ARR/ARPA/LTV/CAC/payback/Rule-of-40/NRR/GRR computed, each with a health tag, plus an overall grade + a ranked "what to fix first" focus list. Deterministic math + advisory, no LLM.

{
  "type": "object",
  "properties": {
    "mrr": {
      "type": "number"
    },
    "customers": {
      "type": "number"
    },
    "prior_mrr": {
      "type": "number"
    },
    "new_mrr": {
      "type": "number"
    },
    "churned_mrr": {
      "type": "number"
    },
    "expansion_mrr": {
      "type": "number"
    },
    "cac": {
      "type": "number"
    },
    "gross_margin_pct": {
      "type": "number"
    },
    "sales_marketing_spend": {
      "type": "number"
    },
    "new_customers": {
      "type": "number"
    }
  },
  "required": [
    "mrr",
    "customers"
  ]
}

QA advisor: validate acceptance criteria quality. POST a list of AC (or a story) and get per-AC problems (vague/untestable, non-atomic, no observable outcome) + a missing-coverage flag if there is no failure-path AC, plus a 0-100 score and pass/needs_work verdict. Tells you exactly what to fix. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "acceptance_criteria": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "story": {
      "type": "string"
    },
    "strictness": {
      "type": "string",
      "enum": [
        "normal",
        "strict"
      ]
    }
  }
}

Scope-completeness advisor. POST a brief (or requirements[]) + your stories[] and get a coverage score + the gaps (requirements no story covers), orphan stories (possible scope creep), and missing structural buckets (auth/CRUD/error-states/tests). Tells you what the scope is missing. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "brief": {
      "type": "string"
    },
    "requirements": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "stories": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "stories"
  ]
}

Bug-triage advisor. POST one bug report (or a list) and get severity (critical/high/medium/low), category, whether it has repro steps, and what info is missing (no repro / no expected-vs-actual / no environment). For a list: priority ranking + likely-duplicate clusters. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "report": {
      "type": "string"
    },
    "reports": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  }
}

LLM selection + cost advisor. POST a task description (+ optional volume/tokens/constraints like local-only or cheap) and get a recommended model + fallback chain + do-not-use (with reasons), the complexity tier, and per-run + monthly cost. A maintained model+price catalog. Deterministic, no LLM. Tells the AI/user which model to use and what it costs.

{
  "type": "object",
  "properties": {
    "task": {
      "type": "string"
    },
    "volume_per_month": {
      "type": "number"
    },
    "tokens_in": {
      "type": "number"
    },
    "tokens_out": {
      "type": "number"
    },
    "constraints": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "top_n": {
      "type": "integer",
      "minimum": 1,
      "maximum": 10,
      "default": 1,
      "description": "How many ranked models to return as primary+fallbacks (rest land in also_considered). Default 1 = primary alone."
    },
    "models": {
      "type": "array",
      "minItems": 1,
      "maxItems": 50,
      "items": {
        "type": "string",
        "minLength": 1
      },
      "description": "Optional allowlist - restrict ranking to only these model identifiers (e.g. models you already have access to). Any catalog model not in this list is excluded, listed in do_not_use."
    }
  },
  "required": [
    "task"
  ]
}

Which QL-API endpoint fits this task. POST a task description and get the ranked endpoint(s) that best match, each with a confidence label (high/medium/low). Deterministic keyword matching over this platform's own endpoint catalog, no LLM. Pairs with model_advisor (which itself is one of the recommendable endpoints, so a "which model" task surfaces it) - call them independently and chain the results yourself; optionally pass a prior model_advisor result's rationale in as `context` to bias matching.

{
  "type": "object",
  "properties": {
    "task": {
      "type": "string",
      "description": "What you are trying to do."
    },
    "context": {
      "type": "string",
      "description": "Optional extra text to fold into matching - e.g. a prior model_advisor rationale, or more detail than fits in `task`."
    },
    "top_n": {
      "type": "integer",
      "minimum": 1,
      "maximum": 20,
      "default": 1,
      "description": "How many ranked endpoints to return. Default 1 = best match only."
    },
    "tools": {
      "type": "array",
      "minItems": 1,
      "maxItems": 20,
      "items": {
        "type": "string",
        "minLength": 1
      },
      "description": "Optional allowlist - restrict matching to only these endpoint names."
    }
  },
  "required": [
    "task"
  ]
}

Rewrite text to remove AI-writing tells. POST prose and get it back with the mechanical tells fixed (AI vocabulary swapped for plain words, filler phrases stripped, em-dash overuse reduced, significance inflation deflated) plus a change log, before/after ai-ness scores, and a residual list of tells that need human judgment (not auto-rewritten). Code fences, inline code, URLs, and quotes are never touched. Deterministic, no LLM. Sister to humanizer_score (the detector).

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The prose to rewrite (up to 100k chars)."
    }
  },
  "required": [
    "text"
  ]
}

Dependency-manifest hygiene check. POST package manifests (package.json, requirements.txt, pyproject.toml, go.mod, Gemfile, composer.json, pubspec.yaml, lockfiles) or an upload_id and get findings with severity + concrete fixes: wildcard/unbounded versions, missing lockfiles, unpinned installs, non-https indexes, install-script risks, dependency-confusion signals, and matches against a static snapshot of famously compromised packages. NOT a live CVE feed - pair with npm audit / pip-audit / osv-scanner for that. Deterministic, no network, no LLM.

{
  "type": "object",
  "properties": {
    "manifests": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "filename": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "filename",
          "content"
        ]
      },
      "description": "Up to 20 manifest files inline."
    },
    "upload_id": {
      "type": "string",
      "description": "Alternative: a single manifest uploaded via the uploads tool."
    },
    "filename": {
      "type": "string",
      "description": "Required with upload_id so the manifest type can be detected."
    }
  }
}

Generate a concrete audit-logging spec for an app. POST your feature list (and optional compliance targets: soc2/hipaa/gdpr/pci) and get a full audit-event catalog (namespaced event names, actor/target/required fields, PII flags, retention), a canonical event envelope schema, a storage plan (append-only, access control, alerting), and per-framework compliance notes. A dev team can implement it directly. Deterministic, no LLM. Retention/compliance figures are common-practice defaults to verify with counsel.

{
  "type": "object",
  "properties": {
    "features": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "App features, e.g. [\"user login\", \"payments\", \"file upload\"]."
    },
    "compliance": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "soc2",
          "hipaa",
          "gdpr",
          "pci"
        ]
      }
    },
    "description": {
      "type": "string",
      "description": "Optional free-text app description (scanned for features)."
    },
    "stack": {
      "type": "string"
    }
  }
}

Analyze a log file. POST raw log text (or an upload_id from the uploads tool, up to 5MB) and get: level breakdown + time range, error clusters (messages normalized so variable ids/numbers collapse into one signature, with counts + first/last seen + a sample), a timeline, detected anomalies (error spikes, retry storms, new error signatures, log gaps/outages, level-ratio shifts) with evidence, and templated recommendations. Handles JSON-lines and plain formats (ISO8601/syslog/CLF/epoch timestamps). Deterministic, single-pass, no LLM.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Raw log content (up to 1M chars)."
    },
    "upload_id": {
      "type": "string",
      "description": "Alternative: a log file uploaded via the uploads tool."
    },
    "top_n": {
      "type": "number",
      "description": "Top clusters to return (1-50, default 10)."
    },
    "format": {
      "type": "string",
      "enum": [
        "auto",
        "json",
        "plain"
      ]
    }
  }
}

Full Jira-ticket quality linter (whole ticket, not just AC - use acceptance_criteria_validator for the deep AC pass). POST one ticket or a batch (max 50) and get per-ticket findings with severity + concrete fixes: missing/weak summary or description, missing AC or estimate, bugs without repro/expected-vs-actual/environment, missing epic link, points-vs-hours mismatch, oversized estimates to split, urgent-but-thin tickets. Returns score, grade, and a ready/needs_work verdict per ticket plus batch summary. Type-aware rules (story/bug/task/epic/subtask), strict profile available. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "ticket": {
      "type": "object",
      "description": "One ticket: {key, summary, description, acceptance_criteria, issue_type, estimate_hours|story_points, priority, labels, components, epic_link, ...}. Missing fields ARE findings."
    },
    "tickets": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Alternative: batch of up to 50 tickets."
    },
    "profile": {
      "type": "string",
      "enum": [
        "normal",
        "strict"
      ]
    }
  }
}

Deterministic structural quality linter for user stories - a sibling to ticket_lint but scoped to story-writing concepts any team recognizes: narrative completeness (As-a/I-want-to/So-that/Summary), acceptance criteria presence, duplicate/unknown dependency IDs, a "Manage X" story with no CRUD split, list stories missing a pagination mention. An OPTIONAL rate_config unlocks team-specific checks (screen-vs-narrative match, hour-rate-per-screen tolerance, required risk level by story type, milestone-code format, required companion story types per milestone) - omit it and only the universal checks run. No house rates or milestone conventions are hardcoded. POST one story or a batch (max 50). Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "story": {
      "type": "object",
      "description": "One story: {id, title, story: {as_a, i_want_to, so_that, summary, type_label?, on_screen?}, acceptance_criteria, dependencies?: [id], screen?, hours?: {<field>: number}, risk?, milestone_code?}. Missing fields ARE findings."
    },
    "stories": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Alternative: batch of up to 50 stories. Dependency/duplicate/required-companion checks are evaluated across the whole batch."
    },
    "rate_config": {
      "type": "object",
      "description": "Optional. Enables team-specific checks, all off by default.",
      "properties": {
        "check_screen_match": {
          "type": "boolean",
          "description": "Flag when story.on_screen disagrees with story.screen."
        },
        "rates": {
          "type": "object",
          "description": "Per type_label: {hours_field, hours_per_screen, tolerance?}. Flags hours[hours_field] that deviate from screens * hours_per_screen by more than tolerance (default 0.15)."
        },
        "risk_required_types": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "type_labels that must carry a valid risk level."
        },
        "risk_levels": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Valid risk values. Default high/medium/low."
        },
        "milestone_code_pattern": {
          "type": "string",
          "description": "Regex the milestone_code field must match."
        },
        "required_companion_types": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string"
              },
              "label": {
                "type": "string"
              }
            }
          },
          "description": "Batch-level only: for each milestone group (milestone_code prefix before the first \"-\"), flag if no story has this type_label."
        }
      }
    }
  }
}

Deterministic classifier for story/task hour estimates against benchmarks: flags each estimate in_range, borderline, over, under, or unbenchmarked. Supply either an explicit {min, max} range per type (benchmarks) or a list of historical actual hours per type (historical) that this endpoint derives a mean/stdev variance band from - explicit ranges win when both are given for the same type. No benchmark numbers are built in; a type with neither input is reported unbenchmarked, never guessed at. POST one estimate or a batch (max 200). Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "estimate": {
      "type": "object",
      "description": "One item: {id?, type, hours}. type and hours are required."
    },
    "estimates": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Alternative: batch of up to 200 items."
    },
    "benchmarks": {
      "type": "object",
      "description": "Optional. Per type: {min?, max?}. Wins over historical for the same type.",
      "additionalProperties": {
        "type": "object",
        "properties": {
          "min": {
            "type": "number"
          },
          "max": {
            "type": "number"
          }
        }
      }
    },
    "historical": {
      "type": "object",
      "description": "Optional. Per type: array of past actual hours (max 500 each), used to derive mean/stdev when no explicit benchmark exists for that type. Needs at least 2 values to produce a band.",
      "additionalProperties": {
        "type": "array",
        "items": {
          "type": "number"
        }
      }
    },
    "borderline_z": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 10,
      "description": "Default 1.0. Stdevs from the historical mean before a result is \"borderline\" instead of \"in_range\"."
    },
    "flag_z": {
      "type": "number",
      "exclusiveMinimum": 0,
      "maximum": 10,
      "description": "Default 2.0. Stdevs from the historical mean beyond which a result is \"over\"/\"under\" instead of \"borderline\". Must be >= borderline_z."
    }
  }
}

Deterministic PR description quality linter: flags a missing/too-short body, absent test evidence, absent stated rationale, an unstructured long body, and - only for PRs that look like bugfixes (title prefix fix/bug/hotfix/patch, or an explicit is_bugfix flag) - missing repro steps. Optionally requires a linked issue/ticket reference. Single PR only, no batch. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "pr": {
      "type": "object",
      "description": "{title?, body?, is_bugfix?}. is_bugfix overrides title-based inference when supplied.",
      "properties": {
        "title": {
          "type": "string"
        },
        "body": {
          "type": "string"
        },
        "is_bugfix": {
          "type": "boolean"
        }
      }
    },
    "require_issue_link": {
      "type": "boolean",
      "description": "Default false. When true, flags a missing issue/ticket reference in the title or body."
    }
  },
  "required": [
    "pr"
  ]
}

Deterministic commit-message hygiene checker: conventional-commit format, vague-subject detection, subject-length limit, a same-message secret-pattern scan (AWS keys, private key headers, Slack/GitHub tokens, inline password=/secret= style credentials - checked against the message text only, never a diff), and an oversized-commit warning from caller-supplied insertions/deletions. POST one commit or a batch (max 200). Deterministic, no LLM, no network.

{
  "type": "object",
  "properties": {
    "commit": {
      "type": "object",
      "description": "One commit: {sha?, message, insertions?, deletions?}. message is required."
    },
    "commits": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Alternative: batch of up to 200 commits."
    },
    "max_lines_changed": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "description": "Default 500. Total insertions+deletions above this triggers a large_commit finding."
    }
  }
}

Deterministic Flesch Reading Ease and Flesch-Kincaid Grade Level for a block of text, plus word/sentence/syllable counts and a plain-language reading-ease band (very_easy through very_confusing). Syllable counting is the standard vowel-group heuristic (same approximation used by textstat and most open readability tools), not a dictionary lookup. Optionally pass target_grade to get an on_target flag (within +/-2.0 grade levels). Different metric family from humanizer_score - this is pure readability statistics, not AI-writing-tell detection. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Prose to analyze. Max 100,000 characters."
    },
    "target_grade": {
      "type": "number",
      "minimum": 0,
      "maximum": 20,
      "description": "Optional target Flesch-Kincaid grade level, 0-20."
    }
  },
  "required": [
    "text"
  ]
}

Static safety analysis of a regular expression plus an English explanation of what it matches. Parses the pattern into an AST and flags the structures that cause catastrophic backtracking (ReDoS): nested unbounded quantifiers like (a+)+, repeated alternations whose branches can start with the same character like (a|ab)*, adjacent unbounded quantifiers over overlapping character sets like \d+\d+, and implausibly large bounded repeats. The pattern is COMPILED but never EXECUTED against input - running a caller-supplied regex is itself the denial-of-service vector. Detection is a structural heuristic, so a risk of "none" means no known dangerous shape was found, not a proof of safety. Deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "The regular expression source, without delimiters. Max 2,000 characters."
    },
    "flags": {
      "type": "string",
      "description": "Optional inline flags, any of \"imsxau\" (ignorecase, multiline, dotall, verbose, ascii, unicode)."
    }
  },
  "required": [
    "pattern"
  ]
}

Sprint/delivery health advisor. POST 1-24 sprints (committed/completed points, optional per-ticket estimate-vs-actual data) and get computed metrics each with a good/warn/bad health tag: velocity avg + trend + stability, commitment reliability, spillover rate, mid-sprint scope change, estimate accuracy (median + chronic-overrun pct), and WIP concentration per assignee. Plus an overall grade and a ranked what-to-fix-first focus list. Pure math + advisory, no LLM.

{
  "type": "object",
  "properties": {
    "sprints": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Oldest first: [{name, committed_points, completed_points, added_points?, spillover_points?, tickets?: [{key, estimate_hours, actual_hours, status, assignee}]}]."
    },
    "team_size": {
      "type": "number"
    },
    "sprint_length_days": {
      "type": "number",
      "description": "Default 10."
    }
  },
  "required": [
    "sprints"
  ]
}

Worklog/timesheet policy checker - run a batch of worklog entries through configurable guardrails BEFORE posting them to a time-tracking system. Checks: rounding increment (default 0.25h, float-safe), per-entry min/max, per-author daily totals, duplicates, over-estimate alerts (never suggests inflating hours or estimates - flags to PM instead), future dates, weekends, immutable-author edit protection, missing description/ticket. Returns pass/warnings/blocked verdict + per-entry violations with fixes + hour totals by author and date. Caller supplies the reference date - fully deterministic, no LLM.

{
  "type": "object",
  "properties": {
    "entries": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Up to 500: [{author, date \"YYYY-MM-DD\", hours, ticket?, description?, estimate_hours?, already_logged_hours?, id?, edit?, delete?, new?}]."
    },
    "today": {
      "type": "string",
      "description": "Reference date \"YYYY-MM-DD\" for future-date checks."
    },
    "policy": {
      "type": "object",
      "description": "Optional overrides: rounding_increment, max_hours_per_day, max_hours_per_entry, min_hours_per_entry, immutable_authors, require_description, require_ticket, over_estimate_policy (alert|block|ignore), future_dates (block|alert), weekend_policy (allow|alert)."
    }
  },
  "required": [
    "entries",
    "today"
  ]
}

Get a presigned S3 PUT URL to upload a file (policy doc, config, log, up to 5MB) that a file-ingesting endpoint then reads by upload_id. Two-step: call this, PUT your file to the returned url, then pass upload_id to the consuming endpoint. Uploads auto-expire in 1 day and are readable only by your key. Auth required; not billed.

{
  "type": "object",
  "properties": {
    "content_type": {
      "type": "string",
      "description": "MIME type of the file you will PUT (e.g. text/plain, application/json). Default application/octet-stream."
    }
  }
}

Submit free-text feedback about the API - a bug, a feature request, a docs gap, a billing question, or anything else. Tied to your key so we can follow up, but not billed and not a support-ticket SLA. Auth required; not billed.

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string",
      "description": "What you want us to know. Up to 4000 characters."
    },
    "category": {
      "type": "string",
      "enum": [
        "bug",
        "feature_request",
        "docs",
        "billing",
        "other"
      ],
      "description": "Defaults to \"other\"."
    },
    "severity": {
      "type": "string",
      "enum": [
        "low",
        "medium",
        "high"
      ],
      "description": "Optional. Omit if not applicable."
    },
    "endpoint": {
      "type": "string",
      "description": "Optional. Which /v1/* endpoint or MCP tool this is about, e.g. \"/v1/ticket-lint\"."
    },
    "contact_ok": {
      "type": "boolean",
      "description": "Optional, defaults to false. Whether we may follow up with you about this."
    }
  },
  "required": [
    "message"
  ]
}

Get a Stripe Checkout link to top up the credits on the API key you are calling with. Starter pack: $5 for 500 credits. Pro pack: $20 for 2500 credits. 1 credit = $0.01. Give the returned checkout_url to a human to complete payment in a browser; the credits are added to this key automatically once the payment succeeds, usually within seconds. Calling this tool does not charge anything and costs no credits.

{
  "type": "object",
  "properties": {
    "pack": {
      "type": "string",
      "enum": [
        "starter",
        "pro"
      ],
      "description": "Which pack to buy. Defaults to \"starter\" ($5 / 500 credits). \"pro\" is $20 / 2500 credits."
    },
    "packs": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "description": "How many of that pack. Defaults to 1."
    }
  }
}

Rate a specific prior metered call - thumbs up or down, plus an optional comment - keyed by the request_id that call's response reported. Scoped for now to rating compress calls, so you can tell us when a compression was too aggressive or dropped something it shouldn't have. Resubmitting the same request_id overwrites your previous rating rather than adding a second one. Auth required; not billed - rating a call you already paid for should not cost more.

{
  "type": "object",
  "properties": {
    "request_id": {
      "type": "string",
      "maxLength": 100,
      "description": "The request_id from the response of the call you are rating."
    },
    "rating": {
      "type": "string",
      "enum": [
        "up",
        "down"
      ]
    },
    "comment": {
      "type": "string",
      "maxLength": 1000,
      "description": "Optional. What was good or wrong about that call's result."
    }
  },
  "required": [
    "request_id",
    "rating"
  ]
}

Scan package manifests, lockfiles, and MCP server configs for known supply-chain compromises. The only scanner treating MCP configuration as a security surface. Returns findings with severity and remediation.

{
  "type": "object",
  "properties": {
    "archive_base64": {
      "type": "string",
      "description": "Base64-encoded ZIP of manifests/lockfiles/MCP configs."
    },
    "archive_url": {
      "type": "string",
      "description": "Presigned HTTPS URL to a ZIP (for large archives)."
    },
    "ecosystems": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional ecosystem filter."
    }
  }
}

Turn a plain-English description into Mermaid diagram source. Describe the flow, system, schema or timeline you want ("a login flow with an OAuth branch and a failure path") and get back complete, valid Mermaid - no need to know the syntax. The mermaid field of the response is directly usable as the mermaid_source input of convert_diagram, so describe -> render is a two-call pipeline. Generation runs on our infrastructure via AWS Bedrock; your description is not sent to any third-party service beyond that.

{
  "type": "object",
  "properties": {
    "description": {
      "type": "string",
      "maxLength": 8000,
      "description": "What the diagram should show, in plain language. Include the nodes/steps/entities you care about; the generator fills in sensible structure."
    },
    "diagram_type": {
      "type": "string",
      "enum": [
        "auto",
        "flowchart",
        "sequence",
        "class",
        "state",
        "er",
        "gantt",
        "pie",
        "mindmap",
        "timeline"
      ],
      "description": "Force a specific Mermaid diagram type. Default \"auto\" - the generator picks the type that fits the description."
    }
  },
  "required": [
    "description"
  ]
}

Make Mermaid diagrams portable. Takes HTML containing <div class="mermaid"> blocks (or a raw Mermaid source) and returns the same document with every diagram pre-rendered to inline SVG and the Mermaid CDN runtime stripped. A CDN-backed diagram only renders if the reader can fetch and run the runtime; inline SVG needs neither, so the output survives offline readers, email clients, Notion/Confluence (which strip <script>), and PDF export. Rendering happens on our infrastructure; diagram content is not sent to any third party.

{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "description": "HTML document or fragment containing <div class=\"mermaid\"> blocks. Mutually exclusive with mermaid_source."
    },
    "mermaid_source": {
      "type": "string",
      "description": "A single raw Mermaid diagram source. Mutually exclusive with html."
    },
    "output_format": {
      "type": "string",
      "enum": [
        "html",
        "svg"
      ],
      "description": "Default \"html\". \"svg\" returns the raw inline SVG and requires mermaid_source."
    },
    "inject_lightbox": {
      "type": "boolean",
      "description": "Add click-to-enlarge overlay CSS+JS for small-text diagrams. Default false."
    },
    "theme": {
      "type": "string",
      "enum": [
        "default",
        "dark",
        "forest",
        "neutral",
        "base"
      ],
      "description": "Mermaid theme. Default \"default\"."
    },
    "background": {
      "type": "string",
      "description": "\"transparent\" (default), \"white\", or a hex color."
    }
  }
}