Loading ToolBench
A Model Context Protocol server that exposes a running Quoin.app text editor as an MCP server, allowing Claude and other MCP clients to read/write documents, manage selections, execute commands, and subscribe to buffer changes via a unix-domain socket.
Quoin MCP server has well-structured tool definitions with clear naming (verb_noun pattern: quoin_list_*, quoin_read_*, quoin_replace_*) and comprehensive descriptions (avg 150+ chars). All 9 tools have input schemas with type definitions and parameter descriptions. However, output schemas are not explicitly documented in the visible code, responses are inferred from the AgentResponse structure. Parameter descriptions are generally good but lack explicit constraints (e.g., line numbers should specify 1-based indexing more prominently in schema). Error handling is minimal, most errors are generic strings without recovery guidance. Tool annotations (readOnlyHint, destructiveHint) are present for some tools but not consistently applied across all 9.
Get the current selection(s) of an open document as UTF-16 offsets, plus the primary selection's text.
List every Quoin command: ID, title, keybinding, and whether it is agent_runnable (safe for an agent to invoke). Commands that write are agent_runnable; save/revert/close/quit are not.
List documents open in Quoin: path (null for unsaved), display name, dirty flag, and which is frontmost.
Open a file in Quoin (creates a tab or fronts the existing one), optionally jumping to a 1-based line.
Read the LIVE buffer of an open document, including unsaved edits (what the user currently sees, which may differ from the file on disk). For a large file prefer quoin_read_lines.
Read lines from...to (1-based, inclusive) of an open document's LIVE buffer, plus its total line count. The token-cheap way to look at part of a file.
Output schemas not documented. AgentResponse structure is inferred from code; LLMs cannot see what fields to expect from each tool's response (e.g., quoin_read_buffer returns path, dirty, can_undo, line_count, text, but this is not in the tool definition).
Error handling lacks recovery guidance. Errors are generic strings ('no such open document', 'line range out of bounds') without actionable next steps. LLMs cannot determine if an error is retryable, user-fixable, or fatal.
Parameter constraints not formalized. Line numbers are 1-based (documented in descriptions) but not enforced in schema with minimum/maximum. The 'line' parameter in quoin_open_file accepts both integer and string but lacks clarity on string format.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 63 | 2026-07-28+ | v2 |
Replace lines from...to (1-based, inclusive) with new text. The replacement text should have no trailing newline; the app preserves the neighbors' line structure. One undoable edit; nothing is saved to disk until the user saves.
Replace the user's current selection with new text (e.g. a grammar-corrected version). Lands in the buffer as one undoable edit, left selected; nothing is saved to disk until the user saves.
Run a Quoin command by ID (e.g. 'edit.undo', 'file.save'). The command must be agent_runnable (read the list_commands output). Commands that write (e.g. replace_selection, replace_lines) are agent_runnable; save/revert/close/quit are not.
Tool annotations incomplete. quoin_replace_selection and quoin_replace_lines are marked REVERSIBLE (correct), but quoin_run_command lacks annotation despite potentially executing destructive commands (e.g., 'edit.undo', 'file.save'). Inconsistent annotation across similar tools.
Pagination not supported. quoin_list_open_documents and quoin_list_commands return unbounded arrays. If a user has hundreds of open documents or commands, the response could exhaust context. No limit or pagination parameters offered.