A code-mode MCP proxy that aggregates multiple MCP servers behind search() + execute() tools. Allows clients to discover tools across all connected servers and execute them via TypeScript code.
This MCP server exposes only 2 tools with highly unusual semantics: 'search' and 'execute' are meta-tools that accept arbitrary TypeScript code as parameters, not traditional tools that perform discrete actions. While the tool definitions themselves are present with schemas and descriptions, they violate fundamental tool design principles. The 'execute' tool is flagged IRREVERSIBLE but lacks confirmation/dry-run patterns. Both tools accept free-form code strings with no constraint or validation guidance in the schema. Parameter descriptions are present but generic. No output schema is documented, the response structure is unspecified. Error handling is minimal ('search error: {e}' and bare exception messages). The design pattern of code-execution-as-a-tool is architecturally risky and does not follow the 54 Agentic Tool Patterns, which emphasize discrete, composable, well-constrained tools. For a proxy aggregator this may be intentional, but it creates high cognitive load on the calling agent and opens surface area for injection attacks.
Execute TypeScript code that calls tools across all connected MCP servers. Each server is a typed global object (e.g. `canva`, `figma`) where every tool is an async function with typed parameters: `await server.tool_name({ param: value })`. Chain calls sequentially or run them in parallel with Promise.all across different servers.
Search across all tools from all connected MCP servers. Write TypeScript code to filter the tool catalog. A typed `tools` array is available with { server, name, description, input_schema } fields.
No input validation or constraint specification in tool schemas. Both 'code' parameters accept unbounded strings with no regex pattern, max length, or syntax validation hint. LLM has no guidance on acceptable code complexity, timeout behavior, or security boundaries.
Output schemas are not documented. Tool definitions specify CallToolResult with Content::text() and Content::image(), but the response structure (field names, types, nesting) is not declared in the tool input_schema. LLM cannot plan downstream extraction of results.
'execute' is marked IRREVERSIBLE but provides no confirmation step, dry-run parameter, or undo mechanism. An LLM could accidentally trigger destructive remote tool calls (delete, send, publish) without a safety gate.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | F | 45 | <=2025-11-25 | v2 |
| 2026-03-09 | F | 0 | - | v1 |
Error handling is minimal and non-actionable. On search/execute failure, responses include only the error message (e.g. 'search error: {e}'). No categorization (retryable vs. user-fixable vs. fatal), no recovery guidance, no invalid value echoing for self-correction.
No input sanitization or injection attack mitigation documented. Tools accept arbitrary TypeScript code as a parameter. While rquickjs sandbox may provide isolation, the tool definitions do not declare sandboxing, code review, or abuse prevention, an LLM calling these tools has no assurance against prompt injection or malicious code execution.
Tool names violate verb_noun clarity. 'search' and 'execute' are generic action words without a clear object. Should be 'search_tools', 'filter_tools', 'execute_remote_tools', or 'call_tools' to disambiguate from other search/execute operations in a larger agent context.
Code-as-parameter design violates single-responsibility principle. Both tools accept arbitrary TypeScript, blurring the line between read (search) and write (execute) operations. A future caller might pass destructive code to 'search' expecting a read-only filter, or pass a simple discovery query to 'execute' expecting a dry-run.