Universal Prompt Gate MCP Server
Use this MCP server to rewrite/enrich prompts and gate prompt approval before an agent sends them to an LLM.
Rewrite a prompt at
light/balanced/detailedenrichment levels without approving it (rewrite_prompt).Run a user-confirmed prompt gate (
review_and_select_prompt) that shows original vs rewritten and lets the user chooseoriginal,rewritten, orcancel; it never auto-selects.If MCP elicitation is unavailable, use plain-text fallback menus (
pending_user_selection) and re-call with the user's explicit selection and exact rewritten text.The README documents an
updateloop where user feedback triggers another rewrite; the provided schema only exposesoriginal/rewritten/canceland omitsreview_id/feedback.Check client capabilities such as elicitation support, transport, integration mode, and whether mandatory gating is enforceable (
get_client_capabilities).Use local llama.cpp/OpenAI-compatible or custom LLM providers with timeout, retry, rate limiting, redaction, and no silent fallback.
Allows the MCP server to use OpenAI as a cloud LLM provider for rewriting and enriching prompts, providing an alternative to local llama.cpp or custom endpoints.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Universal Prompt Gate MCP Server review and rewrite this prompt: thông tin việt nam"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Universal Prompt Gate MCP Server
A standalone MCP server that works with many coding agents. It lets users review and select a prompt before it is sent to an LLM. It rewrites prompts using a local LLM, has the user pick the enrichment level first, displays 4 choices (original / rewritten / update / cancel — "update" requests changes and loops), and keeps the flow safe and flexible for agents.
Core use case
You type a short prompt in an agent:
"thông tin việt nam"First, the user picks the enrichment level (light / balanced / detailed). The MCP server then rewrites (enriches) it with a local LLM (llama.cpp) into:
"Summarize the latest news about Vietnam today, categorized by economy, politics, society, and technology. Prioritize reliable sources."
Before the prompt is forwarded to the large LLM, the user is shown 4 choices:
[1] Use original prompt ("thông tin việt nam")
[2] Use rewritten prompt (the enriched version above)
[3] Update (enter feedback → the prompt is rewritten again; loops)
[4] Cancel (do not call the LLM)The user picks one; the chosen prompt (or a "cancelled" state) is then sent to the large LLM. If they pick update, they describe what to change and the prompt is rewritten again — the menu keeps looping until they choose original, rewritten, or cancel. This is the core flow of the server.
Related MCP server: Hivelore
Key features
Prompt review & rewrite before sending: every prompt passes through a "gate"; nothing is forwarded automatically
User picks the enrichment level:
light/balanced/detailed— interactive picker, never agent-chosen4 user choices: (1) use the original, (2) use the rewritten, (3) update — request changes and review another rewrite (loops), (4) cancel
Rewrite = context enrichment: adds missing context, output structure, and quality criteria — no new intent, avoiding drift
Local LLM rewrite (llama.cpp, OpenAI-compatible) — prompts never leave your machine
Works with many coding agents: Claude Code, Cursor, Cline, Continue, OpenCode, …
2 integration modes:
Standard MCP mode — the agent calls the tool; the MCP server handles the elicitation UI
Mandatory Gating (when the agent supports hooks) — the prompt is not forwarded until the user confirms
Multi-provider LLM: local llama.cpp, OpenAI (cloud), custom endpoint
Safety: no full-prompt logging, no shell execution from prompts, secrets redacted in logs, timeout & cancellation, no placeholder credentials
MCP tools
Tool | Main input | Main output |
|
|
|
|
| Approved: |
| — |
|
Key principles:
rewrite_promptnever claims the rewritten prompt is approved — it only produces a candidate rewrite.
review_and_select_promptis the "gate" tool — it returns an approved prompt only after the user explicitly chooses.Cancel ≠ approved: when the user cancels, the response is a distinct protocol outcome (
status=cancelled) and never exposes an approved prompt.No silent fallback: on LLM error, the original is not auto-selected. A clear error is returned.
No auto-select on timeout: the user must choose manually; nothing is auto-selected by default.
Verified approval (integrity): every
pending_user_selectionstores its state server-side and returns areview_id. A re-call that passesselectionMUST carry thatreview_id; the server then verifies the prompt and rewritten text against the stored review, so a re-call can only approve the exact text the user saw — a substitutedrewritten_promptis rejected.
Full schema & behavior: docs/ARCHITECTURE.md.
Installation
Requires Node.js 20+.
# 1. Clone & install
cd tool-prompt-rewrite-mcp
npm install
# 2. Build
npm run build
# 3. Run with MCP Inspector (try the tools)
npm run inspectorConfiguration (environment variables)
Create a .env file (see .env.example) or export the variables directly:
Variable | Default | Description |
|
| LLM endpoint (OpenAI-compatible) |
|
| Model name |
|
| API key (for local dev, no real key needed) |
|
| LLM timeout in ms (thinking models on CPU need more time) |
|
| Retry count for network errors (idempotent calls only) |
|
| Max completion tokens (thinking models need a larger budget) |
| (unset) |
|
| (unset) | JSON object merged into the LLM request body (e.g. |
|
| Max LLM requests per rolling minute (client-side). Over the limit calls fail fast with a friendly error and the wait time; |
|
| When the client does not support MCP elicitation, the gate tool returns |
|
|
|
| (unset) | Optional: cloud LLM endpoint |
| (unset) | Custom meta-prompt policy file (presets: |
Two separate axes:
Per-call:
rewrite_level—light/balanced/detailed. In the gate tool (review_and_select_prompt) it is chosen by the user via the picker (the agent must not decide it); inrewrite_prompt(no picker) the agent chooses it directly.Global default (env):
PROMPT_GATE_REWRITE_POLICY_FILE— the meta-prompt preset
rewrite_leveldecides the enrichment depth for that call;PROMPT_GATE_REWRITE_POLICY_FILEselects the meta-prompt used as the system prompt.qwen3.5-9bis an example — verify the model name against your llama.cpp version.
When the client does not support elicitation (text fallback)
Some agents (older VS Code, Cline, Continue, …) do not declare the MCP
elicitation capability. When that happens, the gate tool
review_and_select_prompt cannot show an interactive picker. The server has
two behaviors, controlled by PROMPT_GATE_ECHO_FALLBACK:
true(default) — echo fallback: the flow runs over plain-text menus instead, as up to 4+ calls:Level menu. The first call returns
status: "pending_level_selection"(the prompt has not been rewritten yet — no LLM call) with the three numbered levels:[1] light — minimal changes; keep close to the original [2] balanced — add missing structure, context, and quality criteria [3] detailed — full spec with acceptance criteriaThe agent asks the user which level to use and re-calls the tool with the SAME inputs plus
rewrite_levelset to the user's choice. The agent must never pick for the user.Selection menu. The tool now rewrites the prompt and returns
status: "pending_user_selection"with both versions in plain text and the numbered choices:[1] original — use the user's exact text [2] rewritten — use the LLM-enriched version [3] update — request changes: describe what to adjust, then the prompt is rewritten again [4] cancel — use neither; abort the prompt gateThe agent asks the user, then re-calls with
selectionset to"original"/"rewritten"/"cancel"(and, forrewritten, therewritten_prompttext the user saw).Update loop (optional). If the user picks
"update", the agent re-calls withselection: "update"plusfeedbackcontaining the requested changes (andrewritten_promptof the version they reviewed). The tool rewrites again and returns a NEWpending_user_selection(withrevision_countbumped) to review. Repeat until the user picks original, rewritten, or cancel.Final call. Returns the normal approved/cancelled outcome. This call does not invoke the LLM again.
false— strict: the tool returns a hard compatibility error, as in the original design. Use this when you want to refuse to gate at all unless the client supports elicitation.
The echo fallback is not a silent fallback: it never auto-selects, never forwards the prompt without an explicit user choice (level and version), and cancellation still exposes no approved prompt.
Protocol flow (text diagram)
┌────────────────────────────────────────────────────────────────────────────┐
│ STEP 0 · FIRST CALL │
│ agent → review_and_select_prompt { prompt, context?, language? } │
│ (NO rewrite_level, NO selection — the USER decides everything) │
└──────────────┬─────────────────────────────────────────────────────────────┘
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ STEP 1 · LEVEL (user chooses; agent never decides) │
│ elicitation client → interactive picker (light/balanced/detailed) │
│ no elicitation → status=pending_level_selection │
│ agent asks user → RE-CALL with rewrite_level │
└──────────────┬─────────────────────────────────────────────────────────────┘
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ STEP 2 · REWRITE (one LLM call at the user-chosen level) │
└──────────────┬─────────────────────────────────────────────────────────────┘
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ STEP 3 · SELECTION (user chooses; verified via review_id) │
│ elicitation client → interactive picker (original/rewritten/ │
│ update/cancel) │
│ no elicitation → status=pending_user_selection + review_id │
│ (state stored server-side, TTL 30 minutes) │
│ agent asks user → RE-CALL with review_id + │
│ selection: │
│ ┌─────────────────┼──────────────────┬─────────────────┐ │
│ ▼ ▼ ▼ ▼ │
│ "rewritten" "original" "cancel" "update" │
│ │ │ │ │ │
│ │ │ │ + feedback (+ the │
│ │ │ │ rewritten_prompt │
│ │ │ │ the user saw) │
│ │ │ │ │ │
│ │ │ │ → rewrites again │
│ │ │ │ → NEW pending_user_ │
│ │ │ │ selection + NEW │
│ │ │ │ review_id (loop, │
│ │ │ │ max 25 revisions) │
│ ▼ ▼ ▼ │ │
│ status=approved status=approved status=cancelled │ │
│ selected_prompt= selected_prompt= selected_prompt=null │ │
│ rewritten text original text (nothing forwarded) │ │
└────────────────────────────────────────────────────────────────────────────┘Integrity rules of the loop:
A re-call with
selectionMUST carry thereview_idechoed by the pending result — the server verifies the prompt and the rewritten text against the STORED review, so the agent can only approve the exact text the user saw (a substitutedrewritten_promptis rejected).Pending reviews expire after 30 minutes; an expired
review_idreturns a friendly error telling the agent to restart from the first call (reason: "review_expired"in structuredContent).LLM requests are rate-limited client-side (
PROMPT_GATE_LLM_RATE_LIMIT_PER_MIN, default 60/min); over the limit the call fails fast witherror_kind: "llm_rate_limited"and the wait time in the message.
Run a local LLM (llama.cpp)
# Download a model (one time)
./llama-server -m qwen3.5-9b -c 8192 --port 8080 --api-key local-dev-key
# Verify
curl http://127.0.0.1:8080/v1/modelsThe MCP server calls this endpoint to rewrite prompts. No internet required.
Run the MCP server
# Default (stdio) — for desktop agents
node build/index.js
# Or via package.json
npm startIntegrate with agents
Standard MCP mode is the default and works with every MCP-capable agent. Mandatory Gating (hooks) is an extension — optional, and only possible when the agent exposes a hook API.
Example MCP server configuration
Add the server to your agent's config (common JSON shape):
{
"mcpServers": {
"prompt-gate": {
"command": "node",
"args": ["/absolute/path/to/tool-prompt-rewrite-mcp/build/index.js"]
}
}
}Or, when installed from npm:
{
"mcpServers": {
"prompt-gate": {
"command": "npx",
"args": ["-y", "universal-prompt-gate-mcp"]
}
}
}Each agent has a different configuration mechanism — see the compatibility matrix.
Passing configuration (env) to the server — 3 ways
The server reads config with this precedence (higher wins):
1. Real environment variables (passed by the MCP client via `env`/`environment` in its JSON config)
2. A `.env` file (auto-loaded: PROMPT_GATE_ENV_FILE → CWD → next to build/index.js)
3. Built-in defaultsOption A — env in JSON (recommended when publishing)
Claude Code / Cursor / VS Code Copilot use the mcpServers (or servers) key plus an env field:
{
"mcpServers": {
"prompt-gate": {
"command": "node",
"args": ["/absolute/path/to/build/index.js"],
"env": {
"PROMPT_GATE_LLM_BASE_URL": "http://127.0.0.1:8080/v1",
"PROMPT_GATE_LLM_MODEL": "qwen3.5-9b",
"PROMPT_GATE_LLM_MAX_TOKENS": "4096",
"PROMPT_GATE_TIMEOUT_MS": "300000",
"PROMPT_GATE_LLM_ENABLE_THINKING": "false"
}
}
}
}OpenCode V2 uses
mcp.serverswith anenvironmentfield, andcommandis an array:{ "mcp": { "servers": { "prompt-gate": { "type": "local", "command": ["node", "/absolute/path/to/build/index.js"], "environment": { "PROMPT_GATE_LLM_MODEL": "qwen3.5-9b" }, }, }, }, }
Option B — a .env file (local dev)
Copy .env.example → .env at the repo root. The server loads it automatically at startup (no env needed in JSON). When a client spawns the server from a different CWD, the server looks for .env next to build/index.js (the repo). Set PROMPT_GATE_ENV_FILE=/path/to/.env to point to a specific file.
Option C — custom provider (ship your own, used when publishing)
"env": {
"PROMPT_GATE_PROVIDER": "custom",
"PROMPT_GATE_CUSTOM_PROVIDER_MODULE": "/absolute/path/to/my-provider.js"
}my-provider.js must export:
export function createCustomLLMProvider(cfg) {
// cfg: LLMConfig (baseUrl, model, apiKey, timeoutMs, retryMax, maxTokens, …)
return {
isConfigured: () => true,
chat: async (messages, options) => {
// call your endpoint/model/API, return a STRING (the completion).
// throw on error — the server maps it to a GateError.
return await callYourApi(messages, options);
},
};
}→ Ship this provider as a separate package (e.g. @me/my-llm-provider) and point PROMPT_GATE_CUSTOM_PROVIDER_MODULE at the installed file (require.resolve / absolute path). No need to edit the prompt-gate package source.
Provider-related env variables
Variable | Default | Meaning |
|
|
|
| (unset) | Path to a custom provider module (only used when provider=custom) |
|
| OpenAI-compatible endpoint |
| (unset) | Override the base URL (cloud endpoint) |
|
| Model name |
|
| Max completion tokens |
|
| Timeout in ms |
| (unset) |
|
| (unset) | JSON object merged into the LLM request body |
| (unset) | Explicit path to a |
Which tool to use when
rewrite_prompt— when you just want to see an enriched version, without a user gate (e.g. preview).review_and_select_prompt— when you need a real "gate": the user must choose before the prompt is used. This is the primary tool of the "Universal Prompt Gate".get_client_capabilities— to check whether the connected client supports elicitation, before calling the gate tool.
How it works
Workflow diagram (Mermaid)
flowchart TD
U(["👤 User<br/>types a prompt<br/>e.g. "thông tin việt nam""])
subgraph AGENT["🤖 Coding Agent (MCP client)"]
A1["Calls tool<br/><b>review_and_select_prompt</b>"]
A3["Receives JSON result"]
A4{"Use the result?"}
AOK["Send <b>selected_prompt</b><br/>to the large LLM"]
ASTOP["Stop / report cancelled"]
end
subgraph MCP["🛡️ Universal Prompt Gate MCP Server"]
T["Tool: <b>review_and_select_prompt</b>"]
V["Validate input (Zod)"]
LP["User picks rewrite LEVEL<br/>light / balanced / detailed<br/>(mandatory, before rewrite)"]
R["Call LLM to rewrite at that level"]
RM{"LLM ok?"}
RE["Return error<br/>(<b>no</b> silent fallback)"]
E["Show ORIGINAL & REWRITTEN<br/>via elicitation"]
CHOICE{"User picks one of four"}
O1["Use original"]
O2["Use rewritten"]
O4["Update — request changes<br/>(feedback; rewrites again)"]
O3["Cancel"]
end
subgraph LLM["🧠 Local LLM (llama.cpp)"]
L1["/v1/chat/completions"]
end
U -->|"1. submit prompt"| A1
A1 -->|"2. MCP tool call"| T
T --> V
V -->|"valid"| LP
LP -->|"3. elicitation — user must choose"| R
R -->|"4. fetch"| L1
L1 -->|"5. completion"| R
R --> RM
RM -->|failure| RE
RM -->|success| E
E -->|"6. elicitation"| CHOICE
CHOICE -->|"7a"| O1
CHOICE -->|"7b"| O2
CHOICE -->|"7d"| O4
CHOICE -->|"7c"| O3
O4 -->|"8d. apply feedback → rewrite again (loop)"| R
O1 -->|"8a. approved"| A3
O2 -->|"8b. approved"| A3
O3 -->|"8c. cancelled"| A3
RE -->|error| A3
A3 --> A4
A4 -->|"approved"| AOK
A4 -->|"cancelled / error"| ASTOPDiagram source:
docs/WORKFLOW.md.
Standard MCP Mode
1. Agent submits a prompt ("thông tin việt nam")
2. Agent calls the MCP tool → user picks the enrichment level (light/balanced/detailed)
3. LLM (llama.cpp) rewrites the prompt at that level
4. MCP server returns the original & the rewritten version (via the elicitation UI)
5. MCP server shows the 4 choices (1/2/3/4)
6. User picks one (1/2/3/4) — "update" (3) lets them enter requested changes and the prompt is rewritten again (loop back to step 3)
7. MCP server returns the chosen prompt (or the "cancelled" state)
8. Agent sends that prompt (or stops if cancelled)Mandatory Gating (when the agent supports hooks)
An agent hook intercepts the prompt → calls review_and_select_prompt → inside the MCP server:
User picks the level (light / balanced / detailed)
→ Rewrite the prompt at that level (llama.cpp)
→ Show the choices (original / rewritten / update / cancel; "update" loops with user feedback)
→ User selects & confirms
→ Return the result (or cancel)The prompt is not forwarded when the user picks "Cancel".
Cancellation Flow
User picks Cancel → MCP Server confirms the cancellation → The prompt is not forwarded to the agent/LLM
Response: { status: "cancelled", selected_option: "cancel", selected_prompt: null }Cancel is a distinct protocol outcome — the response does not expose
selected_prompt. There is no silent fallback to the original on LLM errors.
Safety & security
Input length limits, output validation (Zod)
Timeout & cancellation (explicit, no auto-select)
Injection detection; the prompt is treated as untrusted data
Session management (pending requests), isolation per session/request ID, cleanup of abandoned requests
No silent fallback: on LLM error, the original is not auto-selected — a clear error is returned
No auto-select on timeout: the user must choose manually
Cancel = distinct outcome: response
status=cancelled, no approved prompt exposedNo full-prompt logging; secrets redacted in logs; no placeholder credentials
No auto-forward on cancel; no shell execution from prompts
Testing
# Run unit + integration tests (mocked LLM, no llama.cpp required)
npm test
# Watch mode
npm run test:watch
# Coverage
npm run test:coverageTest coverage includes:
Rewrite (success, timeout, malformed, language/context pass-through)
Review/select: user-chosen level picker (before the rewrite), original, rewritten, update+feedback revision loop (both elicitation and text fallback), cancel, cancellation via action, LLM error (no fallback), elicitation unsupported + text fallback flow (
pending_level_selection→pending_user_selection→ approval), invalid selectionCapability detection (conservative default, no name-based inference)
Concurrent sessions (isolation)
Logger (redaction, stderr-only)
Config (env defaults, overrides, clamping)
Development & build
npm run typecheck # tsc --noEmit
npm run lint # eslint
npm run format # prettier
npm run build # tsc
npm run dev # tsx (no build)Project structure
tool-prompt-rewrite-mcp/
├── package.json
├── tsconfig.json
├── tsconfig.test.json
├── eslint.config.js
├── .prettierrc
├── .env.example
├── .gitignore
├── README.md
├── docs/
│ ├── ARCHITECTURE.md
│ ├── AGENT_INTEGRATION.md
│ ├── WORKFLOW.md
│ └── Universal Prompt Gate MCP Architecture.png
├── src/
│ ├── index.ts # entry (stdio)
│ ├── config.ts # load env → typed config
│ ├── logger.ts # safe logger (stderr, redaction)
│ ├── types.ts # shared domain types
│ ├── elicitation.ts # MCP elicitation wrapper
│ ├── capability/
│ │ └── capability.ts # client capability detection
│ ├── session/
│ │ └── session.ts # pending-request management
│ ├── llm/
│ │ ├── index.ts # provider factory (+ rate-limit wrap)
│ │ ├── rateLimit.ts # client-side LLM rate limiter (per minute)
│ │ └── provider.ts # OpenAI-compatible provider + retry
│ ├── rewrite/
│ │ └── rewrite.ts # meta-prompts + RewriteService
│ └── tools/
│ ├── index.ts # tool registration
│ ├── rewritePrompt.ts # rewrite_prompt tool
│ ├── reviewAndSelect.ts # review_and_select_prompt tool (the gate)
│ └── getClientCapabilities.ts
└── test/
├── rewrite.test.ts
├── review.test.ts
├── cancellation.test.ts
├── concurrent.test.ts
├── capability.test.ts
├── config.test.ts
├── logger.test.ts
└── fixtures/
└── llm-mocks.tsRelated documentation
docs/ARCHITECTURE.md— overall architecture, compatibility matrix, env variables, securityMCP Inspector — test & debug the server
llama.cpp — run a local OpenAI-compatible API
Troubleshooting
Symptom | Cause | Fix |
| llama.cpp is slow, the model is too large, or a thinking model on CPU | Increase |
| Wrong API key | Check that |
| The model produced no text (high temperature, small max_tokens) | Lower |
| A thinking model (qwen3/3.5) is not respecting | Use a non-thinking model (e.g. |
Client reports | The client does not support elicitation | Text fallback runs by default: expect |
| The pending review was left unanswered for more than 30 minutes (TTL) | The earlier rewrite can no longer be approved — restart the gate from the first call and relay the user's choice with the fresh |
| The | Re-run the gate from the first call, then relay the user's choice with the |
| More than | Wait the number of seconds given in the error, or raise/disable the limit ( |
Prompt does not go through the gate when using an agent | The agent has no hooks (standard mode) | This is a limit of standard MCP — see Mandatory Gating |
| Not built yet | Run |
License
Available Tools
3 toolsget_client_capabilitiesClient CapabilitiesA
Reports which interaction features are available for the current MCP client/session: elicitation support, structured elicitation, transport, integration mode, and whether a mandatory prompt gate is enforceable. Capabilities are derived from verified protocol negotiation, not from the agent name.
Inputs: no named parameters.
review_and_select_promptPrompt Gate (user-confirmed)A
Generates a rewritten version of the prompt, then asks the user to choose: use original, use rewritten, or cancel. Returns only the approved prompt. Cancellation is a distinct outcome and never exposes an approved prompt.
If the client does not support MCP elicitation, the tool returns a distinct "pending_user_selection" result: it shows both versions in plain text with the three numbered choices and asks the agent to re-call this tool with selection set to the user's choice ("original" / "rewritten" / "cancel"). Never auto-select.
CALLING GUIDE (for the LLM):
FIRST call (rewrite): pass prompt + context; do NOT pass
selection. ALWAYS pass a shortcontext(1-3 sentences) summarizing the conversation so far.If the first call returns status "pending_user_selection": show the two versions to the user, ask which to use, then call again with the SAME inputs PLUS
selectionset to "original", "rewritten", or "cancel" matching the user's choice.Choose
rewrite_levelto fit the task:lightfor quick one-shot answers,balanced(default) for most coding/research work,detailedwhen the user explicitly wants a fully-specified spec.Pass
languageonly when the user wants the rewritten prompt in a language different from the original. Do NOT switch the language on your own judgment — the server auto-detects the prompt language and preserves it by default.
Inputs: prompt (required), context (required), language, selection, +2 more.
rewrite_promptPrompt Rewrite (no approval)A
Re-emit the given prompt with richer context, structure, and quality criteria. This tool only produces a candidate rewrite; it does NOT approve the result. Use review_and_select_prompt for the gated, user-confirmed flow.
CALLING GUIDE (for the LLM):
ALWAYS pass a short
context(1-3 sentences) summarizing the conversation/session so far so the enrichment is grounded. Do not omit it.Choose
rewrite_levelto fit the task:lightfor quick one-shot answers,balanced(default) for most coding/research work,detailedwhen the user explicitly wants a fully-specified spec.Pass
languageonly when the user wants the rewritten prompt in a language different from the original. Do NOT switch the language on your own judgment — the server auto-detects the prompt language and preserves it by default.
Inputs: prompt (required), context (required), language, rewrite_level.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
get_client_capabilities is clearly distinct as a capability probe. rewrite_prompt and review_and_select_prompt overlap in that both generate rewritten prompts, but the descriptions explicitly draw the line: rewrite_prompt produces an unapproved candidate while review_and_select_prompt runs the gated, user-confirmed flow. The boundary is documented, so misselection is unlikely but not impossible.
All names use snake_case with verb-first phrasing (get_*, rewrite_*, review_and_select_*), which is readable and mostly uniform. review_and_select_prompt is a compound verb phrase rather than a simple verb_noun, a minor deviation from the otherwise consistent pattern.
Three tools is a lean surface but each maps to a distinct stage of the workflow: capability discovery, candidate rewrite, and gated approval/selection. The count is slightly thin but well-scoped and nothing feels redundant or padded.
The lifecycle for a prompt-gate server is largely covered: negotiate capabilities, generate a rewrite, and handle user approval including a documented fallback for clients without elicitation. Minor gaps exist around configuration or non-elicitation batch handling, but core agent workflows are supported without dead ends.
Maintenance
Related MCP Connectors
Preventive human-approval write-gate for AI agents: writes commit only after a human approves.
Security gateway for AI agents: policy, approval, and audited execution, no secrets shared.
Pre-execution governance for AI agents. Deterministic PASS/FAIL/REVIEW verdicts, replayable proof.
Human-in-the-loop for AI coding agents — ask questions, get approvals via Slack.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI coding assistants like Cursor and Claude to engage in real-time two-way dialogue, allowing them to pause for clarification and request user confirmation before executing tasks. It features a modern UI for managing interaction prompts, predefined options, and project analysis to reduce errors and API costs.16MIT
- AlicenseAqualityBmaintenanceEnforces team knowledge and workflow policies for AI coding agents by providing context, decisions, and gates before code changes are made.165Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables local, cross-provider preflight validation of LLM integration changes—model, prompt, structured-output, and provider-call modifications—with no-spend checks, evidence on speed, tokens, and cost, and explicit human approval before paid runs.1,603 PyPI3MIT
- FlicenseNot gradedqualityNot gradedmaintenanceEnables autonomous agents and multi-agent frameworks to route actions through deterministic human approval gates before execution. Enforces risk tiers, reversible checkpoints, and token approval bounds so that risky or costly operations can be reviewed, bounded, and rolled back without LLM round-trips.-