cwn-eve-trust-gate 0.1.0

package/LICENSE

@@ -0,0 +1,14 @@
+                                 Apache License
+                           Version 2.0, January 2004
+
+Copyright (c) 2026 Cyber Warrior Network
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied.

package/README.md

@@ -0,0 +1,76 @@
+# eve-trust-gate
+
+[eve](https://github.com/vercel/eve) tools for **Trust Gate** post-quantum, tamper-evident receipts on consequential agent actions.
+
+Trust Gate receipts are signed Ed25519 + ML-DSA-65 (FIPS 204) by the hosted MCP server (no local signing key). Each receipt is verifiable offline from the certificate alone. The hosted server defaults to PQ-required verify (defends against Ed25519-only downgrade); set `TRUST_GATE_REQUIRE_PQ=false` on your own deployment to allow Ed25519-only receipts.
+
+## Install
+
+```bash
+npm install cwn-eve-trust-gate
+```
+
+## Usage
+
+Each tool is a named export. Drop one into `agent/tools/` per file, re-exported as the
+default — eve derives a tool's runtime name from the filename, not from any `name` field
+on the definition:
+
+```ts
+// agent/tools/mint_action_receipt.ts
+export { mintActionReceipt as default } from "cwn-eve-trust-gate";
+```
+
+```ts
+// agent/tools/verify_receipt.ts
+export { verifyReceipt as default } from "cwn-eve-trust-gate";
+```
+
+Repeat for `gateDecision`, `checkEgress`, `runExitDrill` — or use the factory to see all
+five at once:
+
+```ts
+import { createTrustGateTools } from "cwn-eve-trust-gate";
+
+console.log(Object.keys(createTrustGateTools()));
+// ["mintActionReceipt", "verifyReceipt", "gateDecision", "checkEgress", "runExitDrill"]
+```
+
+Typical flow inside an agent:
+
+1. the agent decides to do something consequential
+2. it calls `mint_action_receipt(agentId, operation, target)`
+3. the receipt is stored, attached to the audit log, returned to the user
+4. later anyone (including this same package) can call `verify_receipt(receipt)` to confirm tamper-free
+
+## Configuration
+
+```bash
+# point at a different deployment (self-hosted)
+export TRUST_GATE_URL="https://trust-gate-mcp.onrender.com"
+```
+
+## Tools
+
+| Tool | Purpose |
+|---|---|
+| `mintActionReceipt` | Mint a post-quantum receipt for any consequential agent action. |
+| `verifyReceipt` | Calls the hosted server to verify a receipt's signature and hash. Defaults to PQ-required. |
+| `gateDecision` | Two-phase (PREVIEW/COMMIT) decision gate with a tamper-evident receipt on commit. |
+| `checkEgress` | Classifies outbound data (PUBLIC/INTERNAL/CONFIDENTIAL/RESTRICTED); the caller acts on a RESTRICTED result. |
+| `runExitDrill` | Vendor exit readiness drill, run server-side — checks the hosted server's signing key, model access, data export. |
+
+## Telemetry
+
+Each tool invocation makes one fire-and-forget `GET /x?via=eve&kind=api` against the Trust Gate server. No PII, no cookies, no fingerprinting — just a channel tag so adoption per framework is measurable. Telemetry never blocks or fails the tool.
+
+## Background
+
+* **Trust Gate MCP** — the hosted server: <https://trust-gate-mcp.onrender.com>
+* **eve** — the Vercel agent framework this package targets: <https://github.com/vercel/eve>
+* **Sibling adapters** — same protocol, other frameworks: [langchain-trust-gate](https://github.com/CWNApps/langchain-trust-gate), [crewai-trust-gate](https://github.com/CWNApps/crewai-trust-gate), [llama-index-trust-gate](https://github.com/CWNApps/llama-index-trust-gate)
+* **OAO** — the open-source receipt primitive: <https://github.com/CWNApps/openagentontology>
+
+## License
+
+Apache-2.0.

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Transport layer for the hosted Trust Gate MCP server.
+ *
+ * Same wire protocol as langchain-trust-gate / crewai-trust-gate / llama-index-trust-gate:
+ * one JSON-RPC 2.0 `tools/call` POST to `/mcp`, plus one fire-and-forget telemetry ping to
+ * `/x?via=eve`. No PII, no cookies — telemetry is a bare channel-attribution tag and never
+ * blocks or fails a tool call.
+ */
+export declare const TRUST_GATE_URL: string;
+export declare class TrustGateError extends Error {
+    constructor(message: string);
+}
+interface McpCallOptions {
+    timeoutMs?: number;
+}
+/** H4 (pol.must_do.150): a Trust Gate `kid` is `sha256(pubkey_bytes)[:32]` hex chars —
+ * exactly 128 bits. A `kid` of any other width indicates a malformed or spoofed
+ * response and must not be trusted as a same-notary check. */
+export declare function isValidKid(kid: unknown): kid is string;
+/** One JSON-RPC `tools/call` against the hosted Trust Gate MCP server. */
+export declare function mcpCall(method: string, args: Record<string, unknown>, options?: McpCallOptions): Promise<Record<string, unknown>>;
+/** Fire-and-forget channel-attribution ping. Any failure is swallowed — telemetry
+ * must never block or fail a tool call. */
+export declare function pingTelemetry(kind?: string): void;
+export {};

package/dist/client.js

@@ -0,0 +1,194 @@
+/**
+ * Transport layer for the hosted Trust Gate MCP server.
+ *
+ * Same wire protocol as langchain-trust-gate / crewai-trust-gate / llama-index-trust-gate:
+ * one JSON-RPC 2.0 `tools/call` POST to `/mcp`, plus one fire-and-forget telemetry ping to
+ * `/x?via=eve`. No PII, no cookies — telemetry is a bare channel-attribution tag and never
+ * blocks or fails a tool call.
+ */
+export const TRUST_GATE_URL = process.env.TRUST_GATE_URL ?? "https://trust-gate-mcp.onrender.com";
+const VIA = "eve";
+// R4 (pol.must_do.150): a stalled or malicious server can hold the connection open past
+// headers and drip an unbounded body. 1MB is generous for a receipt/decision JSON payload
+// and small enough to bound memory regardless of how slowly it arrives.
+const MAX_RESPONSE_BYTES = 1_000_000;
+export class TrustGateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TrustGateError";
+    }
+}
+async function withTimeout(run, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await run(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function abortRejection(signal) {
+    return new Promise((_, reject) => {
+        const fail = () => reject(new TrustGateError("Trust Gate response read aborted (timeout)"));
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener("abort", fail, { once: true });
+    });
+}
+/**
+ * Reads a Response body under `signal` and a byte cap. The timeout/abort deadline must
+ * cover this, not just the initial `fetch()` — `fetch()` commonly resolves once headers
+ * arrive, before the body has streamed, so a timer that stops at `fetch()` leaves the body
+ * read unbounded (R4: a stalled-body or unbounded-body resource-exhaustion path).
+ *
+ * Each read races against the abort signal directly (not just a pre-read check) so a
+ * stalled stream is bounded by the timeout even if the underlying runtime's reader
+ * doesn't itself reject on abort.
+ */
+async function readJsonCapped(response, signal) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        // Some runtimes/mocks don't expose a streamable body; fall back to text(), still
+        // under the same signal via the caller's overall withTimeout scope.
+        const text = await Promise.race([response.text(), abortRejection(signal)]);
+        if (text.length > MAX_RESPONSE_BYTES) {
+            throw new TrustGateError(`Trust Gate response exceeded ${MAX_RESPONSE_BYTES} byte cap`);
+        }
+        return JSON.parse(text);
+    }
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await Promise.race([reader.read(), abortRejection(signal)]);
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > MAX_RESPONSE_BYTES) {
+                await reader.cancel().catch(() => { });
+                throw new TrustGateError(`Trust Gate response exceeded ${MAX_RESPONSE_BYTES} byte cap`);
+            }
+            chunks.push(value);
+        }
+    }
+    catch (err) {
+        reader.cancel().catch(() => { });
+        if (err instanceof TrustGateError)
+            throw err;
+        throw new TrustGateError(`Trust Gate response read failed: ${err.message}`);
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder().decode(combined));
+}
+/** H4 (pol.must_do.150): a Trust Gate `kid` is `sha256(pubkey_bytes)[:32]` hex chars —
+ * exactly 128 bits. A `kid` of any other width indicates a malformed or spoofed
+ * response and must not be trusted as a same-notary check. */
+export function isValidKid(kid) {
+    return typeof kid === "string" && /^[0-9a-f]{32}$/i.test(kid);
+}
+/** One JSON-RPC `tools/call` against the hosted Trust Gate MCP server. */
+export async function mcpCall(method, args, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const payload = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: method, arguments: args },
+    };
+    let body;
+    try {
+        body = (await withTimeout(async (signal) => {
+            const response = await fetch(`${TRUST_GATE_URL}/mcp`, {
+                method: "POST",
+                signal,
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json, text/event-stream",
+                    "MCP-Protocol-Version": "2025-03-26",
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                const text = await readJsonCapped(response, signal).catch(() => "");
+                throw new TrustGateError(`Trust Gate MCP ${response.status}: ${JSON.stringify(text).slice(0, 200)}`);
+            }
+            // Body read happens INSIDE the same timed/aborted scope as the fetch itself —
+            // this is the fix for the R4 finding: headers-only resolution no longer leaves
+            // the body read unbounded.
+            return readJsonCapped(response, signal);
+        }, timeoutMs));
+    }
+    catch (err) {
+        if (err instanceof TrustGateError)
+            throw err;
+        throw new TrustGateError(`Cannot reach Trust Gate at ${TRUST_GATE_URL}: ${err.message}`);
+    }
+    if (body.error) {
+        throw new TrustGateError(`Trust Gate MCP error: ${JSON.stringify(body.error)}`);
+    }
+    const result = extractResult(body.result);
+    // H4: any kid present in a response must be well-formed, or the offline same-notary
+    // check this field exists for cannot be trusted. Fail closed rather than pass a
+    // malformed kid through silently.
+    //
+    // The kid can be one level deeper than `result` itself: confirmed live against the
+    // hosted server, mint_action_receipt's structuredContent is itself shaped as
+    // `{ result: { atom_id, kid, ... } }` (not flat) — the Python siblings pass this
+    // exact shape through unmodified too (langchain/crewai's `_mcp_call` never unwraps
+    // it further), so `extractResult` intentionally doesn't either, to keep this
+    // package's return shape identical to the established contract. The kid check
+    // below just needs to look in both places it can actually appear.
+    const kid = findKid(result);
+    if (kid !== undefined && !isValidKid(kid)) {
+        throw new TrustGateError(`Trust Gate response carried a malformed kid (expected 32 hex chars): ${JSON.stringify(kid)}`);
+    }
+    return result;
+}
+function findKid(result) {
+    if ("kid" in result)
+        return result.kid;
+    if (result.result && typeof result.result === "object") {
+        const nested = result.result;
+        if ("kid" in nested)
+            return nested.kid;
+    }
+    return undefined;
+}
+function extractResult(result) {
+    if (result && typeof result === "object") {
+        const r = result;
+        if ("structuredContent" in r) {
+            return r.structuredContent;
+        }
+        if ("content" in r && Array.isArray(r.content) && r.content.length > 0) {
+            const first = r.content[0];
+            if (typeof first.text === "string") {
+                try {
+                    return JSON.parse(first.text);
+                }
+                catch {
+                    return { raw: r.content };
+                }
+            }
+        }
+        return r;
+    }
+    return { raw: result };
+}
+/** Fire-and-forget channel-attribution ping. Any failure is swallowed — telemetry
+ * must never block or fail a tool call. */
+export function pingTelemetry(kind = "api") {
+    withTimeout((signal) => fetch(`${TRUST_GATE_URL}/x?via=${VIA}&kind=${encodeURIComponent(kind)}`, {
+        signal,
+    }), 2_000).catch(() => {
+        /* best-effort only */
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export { TRUST_GATE_URL, TrustGateError, mcpCall, pingTelemetry, isValidKid } from "./client.js";
+export { mintActionReceipt } from "./tools/mint-action-receipt.js";
+export { verifyReceipt } from "./tools/verify-receipt.js";
+export { gateDecision } from "./tools/gate-decision.js";
+export { checkEgress } from "./tools/check-egress.js";
+export { runExitDrill } from "./tools/run-exit-drill.js";
+/**
+ * All 5 Trust Gate tools, ready to drop into an eve `agent/tools/` directory
+ * or spread into a `defineExtension` bundle.
+ */
+export declare function createTrustGateTools(): {
+    mintActionReceipt: import("eve/tools").ToolDefinition<{
+        agentId: string;
+        operation: string;
+        target: string;
+        policy?: string | undefined;
+        inputs?: string | undefined;
+        decision?: string | undefined;
+    }, Record<string, unknown>>;
+    verifyReceipt: import("eve/tools").ToolDefinition<{
+        receipt: Record<string, unknown>;
+        requirePq?: boolean | undefined;
+    }, Record<string, unknown>>;
+    gateDecision: import("eve/tools").ToolDefinition<{
+        action: string;
+        resource: string;
+        context: Record<string, unknown>;
+        phase: "PREVIEW" | "COMMIT";
+        previewId?: string | undefined;
+    }, Record<string, unknown>>;
+    checkEgress: import("eve/tools").ToolDefinition<{
+        destination: string;
+        dataSample: string;
+        provider: string;
+    }, Record<string, unknown>>;
+    runExitDrill: import("eve/tools").ToolDefinition<Record<string, never>, Record<string, unknown>>;
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+export { TRUST_GATE_URL, TrustGateError, mcpCall, pingTelemetry, isValidKid } from "./client.js";
+export { mintActionReceipt } from "./tools/mint-action-receipt.js";
+export { verifyReceipt } from "./tools/verify-receipt.js";
+export { gateDecision } from "./tools/gate-decision.js";
+export { checkEgress } from "./tools/check-egress.js";
+export { runExitDrill } from "./tools/run-exit-drill.js";
+import { mintActionReceipt } from "./tools/mint-action-receipt.js";
+import { verifyReceipt } from "./tools/verify-receipt.js";
+import { gateDecision } from "./tools/gate-decision.js";
+import { checkEgress } from "./tools/check-egress.js";
+import { runExitDrill } from "./tools/run-exit-drill.js";
+/**
+ * All 5 Trust Gate tools, ready to drop into an eve `agent/tools/` directory
+ * or spread into a `defineExtension` bundle.
+ */
+export function createTrustGateTools() {
+    return {
+        mintActionReceipt,
+        verifyReceipt,
+        gateDecision,
+        checkEgress,
+        runExitDrill,
+    };
+}

package/dist/tools/check-egress.d.ts

@@ -0,0 +1,5 @@
+export declare const checkEgress: import("eve/tools").ToolDefinition<{
+    destination: string;
+    dataSample: string;
+    provider: string;
+}, Record<string, unknown>>;

package/dist/tools/check-egress.js

@@ -0,0 +1,23 @@
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import { mcpCall, pingTelemetry } from "../client.js";
+export const checkEgress = defineTool({
+    description: "Egress classification check. The hosted server scans data for sensitivity markers " +
+        "and classifies it as PUBLIC / INTERNAL / CONFIDENTIAL / RESTRICTED, returning that " +
+        "classification plus a tamper-evident receipt. This tool only reports the " +
+        "classification -- it does not itself intercept or block network calls; the caller " +
+        "is responsible for acting on a RESTRICTED result.",
+    inputSchema: z.object({
+        destination: z.string().min(1).describe("Where data is being sent (e.g., 'openai.com')."),
+        dataSample: z.string().min(1).describe("Sample of the data being sent (scanned for sensitivity)."),
+        provider: z.string().min(1).describe("The provider/service receiving the data."),
+    }),
+    async execute({ destination, dataSample, provider }) {
+        pingTelemetry();
+        return mcpCall("check_egress", {
+            destination,
+            data_sample: dataSample,
+            provider,
+        });
+    },
+});

package/dist/tools/gate-decision.d.ts

@@ -0,0 +1,7 @@
+export declare const gateDecision: import("eve/tools").ToolDefinition<{
+    action: string;
+    resource: string;
+    context: Record<string, unknown>;
+    phase: "PREVIEW" | "COMMIT";
+    previewId?: string | undefined;
+}, Record<string, unknown>>;

package/dist/tools/gate-decision.js

@@ -0,0 +1,25 @@
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import { mcpCall, pingTelemetry } from "../client.js";
+export const gateDecision = defineTool({
+    description: "Two-phase decision gate. PREVIEW returns a risk assessment and preview_id " +
+        "without acting. COMMIT requires the preview_id, verifies inputs match, " +
+        "and mints a tamper-evident receipt. Stateless.",
+    inputSchema: z.object({
+        action: z.string().min(1).describe("The action to evaluate (e.g., 'deploy', 'send_email')."),
+        resource: z.string().min(1).describe("Target resource (e.g., 'prod/api', 'user-db')."),
+        context: z.record(z.string(), z.unknown()).describe("Context object for the decision (hashed in the receipt)."),
+        phase: z
+            .enum(["PREVIEW", "COMMIT"])
+            .default("PREVIEW")
+            .describe("'PREVIEW' for risk assessment, 'COMMIT' to proceed with receipt."),
+        previewId: z.string().optional().describe("Required for COMMIT. Returned by the PREVIEW phase."),
+    }),
+    async execute({ action, resource, context, phase, previewId }) {
+        pingTelemetry();
+        const args = { action, resource, context, phase };
+        if (previewId !== undefined)
+            args.preview_id = previewId;
+        return mcpCall("gate_decision", args);
+    },
+});

package/dist/tools/mint-action-receipt.d.ts

@@ -0,0 +1,8 @@
+export declare const mintActionReceipt: import("eve/tools").ToolDefinition<{
+    agentId: string;
+    operation: string;
+    target: string;
+    policy?: string | undefined;
+    inputs?: string | undefined;
+    decision?: string | undefined;
+}, Record<string, unknown>>;

package/dist/tools/mint-action-receipt.js

@@ -0,0 +1,31 @@
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import { mcpCall, pingTelemetry } from "../client.js";
+export const mintActionReceipt = defineTool({
+    description: "Mint a post-quantum, tamper-evident receipt for a consequential agent action. " +
+        "Returns a receipt that's verifiable offline from the certificate alone. " +
+        "Receipt is signed Ed25519 + ML-DSA-65; carries a 128-bit kid for offline " +
+        "same-notary check.",
+    inputSchema: z.object({
+        agentId: z.string().min(1).describe("Identifier of the agent performing the action."),
+        operation: z.string().min(1).describe("Operation name (e.g., 'deploy', 'send_email')."),
+        target: z.string().min(1).describe("Target of the action."),
+        policy: z.string().optional().describe("Policy label for the action (default: 'agent action evidence')."),
+        inputs: z.string().optional().describe("Optional serialized inputs to bind into the receipt."),
+        decision: z.string().optional().describe("Decision label (default: 'ACTION_GOVERNED')."),
+    }),
+    async execute({ agentId, operation, target, policy, inputs, decision }) {
+        pingTelemetry();
+        const args = {
+            agent_id: agentId,
+            operation,
+            target,
+            policy: policy ?? "agent action evidence",
+        };
+        if (inputs !== undefined)
+            args.inputs = inputs;
+        if (decision !== undefined)
+            args.decision = decision;
+        return mcpCall("mint_action_receipt", args);
+    },
+});

package/dist/tools/run-exit-drill.d.ts

@@ -0,0 +1 @@
+export declare const runExitDrill: import("eve/tools").ToolDefinition<Record<string, never>, Record<string, unknown>>;

package/dist/tools/run-exit-drill.js

@@ -0,0 +1,13 @@
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import { mcpCall, pingTelemetry } from "../client.js";
+export const runExitDrill = defineTool({
+    description: "Vendor exit readiness drill. Runs on the hosted Trust Gate server (not the caller's " +
+        "own machine) -- checks the server's own signing key, model access, and data export " +
+        "paths. Returns results + tamper-evident receipt.",
+    inputSchema: z.object({}),
+    async execute() {
+        pingTelemetry();
+        return mcpCall("run_exit_drill", {});
+    },
+});

package/dist/tools/verify-receipt.d.ts

@@ -0,0 +1,4 @@
+export declare const verifyReceipt: import("eve/tools").ToolDefinition<{
+    receipt: Record<string, unknown>;
+    requirePq?: boolean | undefined;
+}, Record<string, unknown>>;

package/dist/tools/verify-receipt.js

@@ -0,0 +1,30 @@
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import { mcpCall, pingTelemetry } from "../client.js";
+export const verifyReceipt = defineTool({
+    description: "Calls the hosted Trust Gate server to verify a receipt's signature and evidence " +
+        "hash (a networked call, not a local/offline check -- the receipt format itself is " +
+        "designed to be independently verifiable offline from the certificate alone, but " +
+        "this tool takes the convenient hosted-verification path rather than performing " +
+        "that check locally). Returns {ok, hash_ok, sig_ok, signed, legs, signature_alg, reason}. " +
+        "Defaults to PQ-required mode on the server -- defends against Ed25519-only downgrade " +
+        "by requiring at least one verified PQ leg.",
+    inputSchema: z.object({
+        receipt: z.record(z.string(), z.unknown()).describe("The Trust Gate receipt to verify."),
+        // H3 (pol.must_do.150): left undefined by default so the hosted server obeys its own
+        // TRUST_GATE_REQUIRE_PQ env (default true). This tool never silently forces it false —
+        // only an explicit caller-supplied `false` opts out of PQ-required verification.
+        requirePq: z
+            .boolean()
+            .optional()
+            .describe("Undefined = obey the server's TRUST_GATE_REQUIRE_PQ (default true). " +
+            "false = allow Ed25519-only receipts (downgrade — opt in explicitly)."),
+    }),
+    async execute({ receipt, requirePq }) {
+        pingTelemetry();
+        const args = { receipt };
+        if (requirePq !== undefined)
+            args.require_pq = requirePq;
+        return mcpCall("verify_receipt", args);
+    },
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "cwn-eve-trust-gate",
+  "version": "0.1.0",
+  "description": "eve (Vercel agent framework) tools for Trust Gate post-quantum, tamper-evident receipts.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --import tsx --test tests/adversarial.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "eve",
+    "vercel",
+    "mcp",
+    "trust-gate",
+    "post-quantum",
+    "agent",
+    "receipt"
+  ],
+  "author": "Cyber Warrior Network <apps@cyberwarriornetwork.com>",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/CWNApps/eve-trust-gate",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CWNApps/eve-trust-gate.git"
+  },
+  "bugs": "https://github.com/CWNApps/eve-trust-gate/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "eve": "^0.24.0"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "eve": "^0.24.4",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "@types/node": "^22.10.0"
+  }
+}