@luveo-tech/vark-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saturn Security
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# `@luveo-tech/vark-mcp`
+
+**Zero-rewrite bridge that wraps Anthropic Model Context Protocol (MCP) tools
+with [`@luveo-tech/vark`](https://www.npmjs.com/package/@luveo-tech/vark) protection.**
+
+Raw MCP descriptors are left byte-identical; vark adds a guard pipeline, an
+`execute()` hook, and a CTP signature:
+
+```ts
+import { VarkRuntime } from '@luveo-tech/vark';
+import { VarkMCPAdapter } from '@luveo-tech/vark-mcp';
+
+const runtime = new VarkRuntime();
+const adapter = new VarkMCPAdapter({
+  runtime, // share the host runtime: same anomaly window, same audit chain
+  executor: async (tool, args) => client.callTool(tool.name, args),
+});
+
+const tools = adapter.wrapTools(mcpTools, {
+  network: { allowedHosts: ['docs.example.com', '*.docs.example.com'] },
+});
+
+await tools[0].execute({ url: 'https://evil.example.net' }); // → CAPABILITY_VIOLATION
+tools[0].check({ url: 'https://docs.example.com' });         // dry run, no server call
+tools[0].compact;                                            // CTP signature
+```
+
+Full documentation in the
+[monorepo](https://github.com/luveo-technologies/vark).
+
+Node 20+ · ESM · MIT

package/dist/bridge.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Anthropic MCP bridge — zero-rewrite protection for Model Context Protocol
+ * tools.
+ *
+ * MCP exposes *schema-only* tool descriptors (`{ name, description,
+ * inputSchema }`); the actual call is a `tools/call` request against the MCP
+ * server. The adapter keeps those descriptors byte-identical and adds three
+ * things around them:
+ *
+ *  - a vark guard pipeline (capabilities + circuit breaker + timeout),
+ *  - an `execute()` hook that performs the server call,
+ *  - a CTP signature so the descriptor can be sent to the model in far fewer
+ *    tokens than the original JSON Schema.
+ *
+ * ```ts
+ * const adapter = new VarkMCPAdapter({ executor: async (tool, args) => client.callTool(tool.name, args) });
+ * const tools = adapter.wrapTools(mcpTools, { network: { allowedHosts: ['api.example.com'] } });
+ * await tools[0].execute({ url: 'https://evil.com' }); // → CAPABILITY_VIOLATION
+ * ```
+ */
+import { VarkRuntime } from '@luveo-tech/vark';
+import type { CapabilityConfig, CompressionReport, ExecutionOptions, ExecutionContext, GuardResult, InspectionResult, ToolExecutionResult, VarkConfig } from '@luveo-tech/vark';
+/** Shape of a raw MCP (or OpenAI-style function) tool descriptor. */
+export interface MCPToolLike {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, any>;
+    /** OpenAI-style alias for `inputSchema`. */
+    schema?: Record<string, any>;
+    [key: string]: unknown;
+}
+/** Performs the real `tools/call` round trip against the MCP server. */
+export type MCPExecutor = (tool: MCPToolLike, args: any, context: ExecutionContext) => Promise<unknown>;
+/** A raw MCP tool after vark has wrapped it. */
+export interface WrappedMCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+    /** Effective grants (defaults merged with the per-wrap defaults). */
+    capabilities: CapabilityConfig;
+    /** CTP signature for this tool. */
+    compact: string;
+    /** CTP signature plus token accounting. */
+    compression: CompressionReport;
+    /** Dry run: guards only, no server call. */
+    check: (args?: unknown, options?: ExecutionOptions) => GuardResult;
+    /** Guarded execution — runs the payload through vark, then the MCP server. */
+    execute: (args?: unknown, options?: ExecutionOptions) => Promise<ToolExecutionResult>;
+}
+export interface VarkMCPAdapterOptions {
+    config?: VarkConfig;
+    executor?: MCPExecutor;
+    /**
+     * Reuse an existing runtime. This is how you keep the MCP tools inside the
+     * host's anomaly-guard window and audit trail (shared sessions, one chain).
+     * When provided, `config` is ignored.
+     */
+    runtime?: VarkRuntime;
+}
+export declare class VarkMCPAdapter {
+    #private;
+    /** The underlying runtime — exposed so hosts can register bespoke tools too. */
+    readonly runtime: VarkRuntime;
+    constructor(options?: VarkMCPAdapterOptions);
+    /**
+     * Wrap raw Anthropic MCP tools with vark protection.
+     *
+     * @param mcpTools          raw `{ name, description, inputSchema }` descriptors
+     * @param defaultCapabilities grants applied to every wrapped tool
+     * @param executor          per-call override for the MCP server round trip
+     */
+    wrapTools(mcpTools: any[], defaultCapabilities?: CapabilityConfig, executor?: MCPExecutor): WrappedMCPTool[];
+    get(name: string): WrappedMCPTool | undefined;
+    list(): WrappedMCPTool[];
+    /** Payload-only inspection (circuit breaker) for a raw argument object. */
+    inspect(args: unknown): InspectionResult;
+    /** Unwrap every tool registered through this adapter. */
+    clear(): void;
+}
+/** Functional shorthand for `new VarkMCPAdapter(options).wrapTools(...)`. */
+export declare function wrapMCPTools(mcpTools: any[], defaultCapabilities?: CapabilityConfig, options?: VarkMCPAdapterOptions): WrappedMCPTool[];
+export type { CompressionReport, ExecutionOptions, ExecutionContext, GuardResult, InspectionResult };
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACX,MAAM,kBAAkB,CAAC;AAG1B,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wEAAwE;AACxE,MAAM,MAAM,WAAW,GAAG,CACxB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,qEAAqE;IACrE,YAAY,EAAE,gBAAgB,CAAC;IAC/B,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,WAAW,EAAE,iBAAiB,CAAC;IAC/B,4CAA4C;IAC5C,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,KAAK,WAAW,CAAC;IACnE,8EAA8E;IAC9E,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACvF;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAUD,qBAAa,cAAc;;IACzB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;gBAKlB,OAAO,GAAE,qBAA0B;IAK/C;;;;;;OAMG;IACH,SAAS,CACP,QAAQ,EAAE,GAAG,EAAE,EACf,mBAAmB,CAAC,EAAE,gBAAgB,EACtC,QAAQ,CAAC,EAAE,WAAW,GACrB,cAAc,EAAE;IAgDnB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI7C,IAAI,IAAI,cAAc,EAAE;IAIxB,2EAA2E;IAC3E,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB;IAIxC,yDAAyD;IACzD,KAAK,IAAI,IAAI;CAId;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,GAAG,EAAE,EACf,mBAAmB,CAAC,EAAE,gBAAgB,EACtC,OAAO,GAAE,qBAA0B,GAClC,cAAc,EAAE,CAElB;AAED,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/bridge.js

@@ -0,0 +1,106 @@
+/**
+ * Anthropic MCP bridge — zero-rewrite protection for Model Context Protocol
+ * tools.
+ *
+ * MCP exposes *schema-only* tool descriptors (`{ name, description,
+ * inputSchema }`); the actual call is a `tools/call` request against the MCP
+ * server. The adapter keeps those descriptors byte-identical and adds three
+ * things around them:
+ *
+ *  - a vark guard pipeline (capabilities + circuit breaker + timeout),
+ *  - an `execute()` hook that performs the server call,
+ *  - a CTP signature so the descriptor can be sent to the model in far fewer
+ *    tokens than the original JSON Schema.
+ *
+ * ```ts
+ * const adapter = new VarkMCPAdapter({ executor: async (tool, args) => client.callTool(tool.name, args) });
+ * const tools = adapter.wrapTools(mcpTools, { network: { allowedHosts: ['api.example.com'] } });
+ * await tools[0].execute({ url: 'https://evil.com' }); // → CAPABILITY_VIOLATION
+ * ```
+ */
+import { VarkRuntime } from '@luveo-tech/vark';
+import { VarkError } from '@luveo-tech/vark';
+function normalizeTool(raw) {
+    if (!raw || typeof raw !== 'object')
+        throw new TypeError('MCP tool descriptor must be an object');
+    const tool = raw;
+    const name = typeof tool.name === 'string' ? tool.name.trim() : '';
+    if (!name)
+        throw new TypeError('MCP tool descriptor is missing "name"');
+    return tool;
+}
+export class VarkMCPAdapter {
+    /** The underlying runtime — exposed so hosts can register bespoke tools too. */
+    runtime;
+    #executor;
+    #tools = new Map();
+    constructor(options = {}) {
+        this.runtime = options.runtime ?? new VarkRuntime(options.config ?? {});
+        this.#executor = options.executor;
+    }
+    /**
+     * Wrap raw Anthropic MCP tools with vark protection.
+     *
+     * @param mcpTools          raw `{ name, description, inputSchema }` descriptors
+     * @param defaultCapabilities grants applied to every wrapped tool
+     * @param executor          per-call override for the MCP server round trip
+     */
+    wrapTools(mcpTools, defaultCapabilities, executor) {
+        const dispatch = executor ?? this.#executor;
+        const wrapped = [];
+        for (const raw of Array.isArray(mcpTools) ? mcpTools : []) {
+            const tool = normalizeTool(raw);
+            if (this.#tools.has(tool.name)) {
+                throw new Error(`MCP tool "${tool.name}" is already wrapped`);
+            }
+            const inputSchema = tool.inputSchema ?? tool.schema ?? {};
+            const capabilities = { ...(defaultCapabilities ?? {}) };
+            const guard = this.runtime.tool({
+                name: tool.name,
+                description: tool.description ?? '',
+                schema: inputSchema,
+                capabilities,
+                run: async (args, context) => {
+                    if (!dispatch) {
+                        throw new VarkError('EXECUTION_ERROR', `MCP tool "${tool.name}" passed every guard, but no executor is bound to call the server`);
+                    }
+                    return dispatch(tool, args, context);
+                },
+            });
+            const entry = {
+                name: tool.name,
+                description: tool.description ?? '',
+                inputSchema,
+                capabilities: guard.capabilities,
+                compact: guard.compact,
+                compression: guard.compression,
+                check: (args, options) => this.runtime.check(tool.name, args, options),
+                execute: (args, options) => guard.execute(args, options),
+            };
+            this.#tools.set(entry.name, entry);
+            wrapped.push(entry);
+        }
+        return wrapped;
+    }
+    get(name) {
+        return this.#tools.get(name);
+    }
+    list() {
+        return [...this.#tools.values()];
+    }
+    /** Payload-only inspection (circuit breaker) for a raw argument object. */
+    inspect(args) {
+        return this.runtime.inspect(args);
+    }
+    /** Unwrap every tool registered through this adapter. */
+    clear() {
+        for (const name of this.#tools.keys())
+            this.runtime.unregister(name);
+        this.#tools.clear();
+    }
+}
+/** Functional shorthand for `new VarkMCPAdapter(options).wrapTools(...)`. */
+export function wrapMCPTools(mcpTools, defaultCapabilities, options = {}) {
+    return new VarkMCPAdapter(options).wrapTools(mcpTools, defaultCapabilities);
+}
+//# sourceMappingURL=bridge.js.map

package/dist/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `@luveo-tech/vark-mcp` — zero-rewrite bridge between Anthropic Model Context
+ * Protocol tool descriptors and the vark guard pipeline.
+ */
+export { VarkMCPAdapter, wrapMCPTools } from './bridge.js';
+export type { MCPExecutor, MCPToolLike, VarkMCPAdapterOptions, WrappedMCPTool, } from './bridge.js';
+export type { ExecutionOptions } from './bridge.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3D,YAAY,EACV,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+/**
+ * `@luveo-tech/vark-mcp` — zero-rewrite bridge between Anthropic Model Context
+ * Protocol tool descriptors and the vark guard pipeline.
+ */
+export { VarkMCPAdapter, wrapMCPTools } from './bridge.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@luveo-tech/vark-mcp",
+  "version": "0.1.0",
+  "description": "Zero-rewrite bridge that wraps Anthropic Model Context Protocol (MCP) tools with vark protection.",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@luveo-tech/vark": "0.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}