aipou-mcp-server 0.2.0

package/dist/policy.d.ts

@@ -0,0 +1,11 @@
+import type { SkippedReceipt, UsageReceipt } from "./types.js";
+export interface SettlementPolicy {
+    minTotalTokens: number;
+    maxDailyReceiptsPerWallet: number;
+}
+export declare const DAY_MS: number;
+export declare function settlementPolicyFromEnv(): SettlementPolicy;
+export declare function filterEligibleReceipts(candidates: UsageReceipt[], recentlySettled: UsageReceipt[], policy: SettlementPolicy, now?: number): {
+    eligible: UsageReceipt[];
+    skipped: SkippedReceipt[];
+};

package/dist/policy.js

@@ -0,0 +1,54 @@
+export const DAY_MS = 24 * 60 * 60 * 1000;
+function positiveIntFromEnv(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isInteger(value) || value < 0)
+        throw new Error(`${name} must be a non-negative integer`);
+    return value;
+}
+// Both checks are opt-in: 0 (the default) disables them, keeping the original
+// settlement behavior unless the operator explicitly sets the env vars.
+export function settlementPolicyFromEnv() {
+    return {
+        minTotalTokens: positiveIntFromEnv("AIPOU_MIN_RECEIPT_TOKENS", 0),
+        maxDailyReceiptsPerWallet: positiveIntFromEnv("AIPOU_MAX_DAILY_RECEIPTS_PER_WALLET", 0)
+    };
+}
+export function filterEligibleReceipts(candidates, recentlySettled, policy, now = Date.now()) {
+    const windowStart = now - DAY_MS;
+    const dailyCount = new Map();
+    for (const receipt of recentlySettled) {
+        if (Date.parse(receipt.recordedAt) >= windowStart) {
+            const wallet = receipt.wallet.toLowerCase();
+            dailyCount.set(wallet, (dailyCount.get(wallet) ?? 0) + 1);
+        }
+    }
+    const eligible = [];
+    const skipped = [];
+    for (const receipt of candidates) {
+        const totalTokens = receipt.inputTokens + receipt.outputTokens;
+        if (policy.minTotalTokens > 0 && totalTokens < policy.minTotalTokens) {
+            skipped.push({
+                receiptId: receipt.receiptId,
+                wallet: receipt.wallet,
+                reason: `below minimum work floor (${totalTokens} < ${policy.minTotalTokens} tokens)`
+            });
+            continue;
+        }
+        const wallet = receipt.wallet.toLowerCase();
+        const used = dailyCount.get(wallet) ?? 0;
+        if (policy.maxDailyReceiptsPerWallet > 0 && used >= policy.maxDailyReceiptsPerWallet) {
+            skipped.push({
+                receiptId: receipt.receiptId,
+                wallet: receipt.wallet,
+                reason: `daily receipt limit reached (${policy.maxDailyReceiptsPerWallet} per wallet per 24h)`
+            });
+            continue;
+        }
+        dailyCount.set(wallet, used + 1);
+        eligible.push(receipt);
+    }
+    return { eligible, skipped };
+}

package/dist/protocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/protocol.test.js

@@ -0,0 +1,165 @@
+import { generateKeyPairSync, sign } from "node:crypto";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Wallet, keccak256, toUtf8Bytes } from "ethers";
+import { canonicalJson } from "./canonical.js";
+import { verifyCollectorPayload } from "./collector.js";
+import { verifyTaskAuthorization } from "./identity.js";
+import { filterEligibleReceipts } from "./policy.js";
+import { providerAssertion } from "./providers.js";
+import { beginTask, completeTask } from "./receipts.js";
+import { exportStoredReceipts, markBatchSettled, unsettledReceipts } from "./store.js";
+test("creates verifiable receipts and rejects nonce/evidence replay", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "aipou-protocol-"));
+    process.env.AIPOU_DATA_DIR = dataDir;
+    process.env.AIPOU_AGENT_PRIVATE_KEY = Wallet.createRandom().privateKey;
+    const verifyingContract = Wallet.createRandom().address;
+    const taskHash = keccak256(toUtf8Bytes("build a useful artifact"));
+    const outputHash = keccak256(toUtf8Bytes("artifact-v1"));
+    const session = await beginTask({
+        provider: "openai",
+        model: "codex",
+        taskHash,
+        client: "test-client",
+        chainId: 8453,
+        verifyingContract
+    });
+    assert.equal(verifyTaskAuthorization(session), true);
+    const receipt = await completeTask({
+        nonce: session.nonce,
+        inputTokens: 1200,
+        outputTokens: 500,
+        durationSeconds: 180,
+        outputHash
+    });
+    assert.equal(receipt.trustTier, "client_signed");
+    const { collectorSignature, batchRoot, claimTransaction, ...signedPayload } = receipt;
+    assert.equal(verifyCollectorPayload(signedPayload, collectorSignature, receipt.collectorPublicKey), true);
+    await assert.rejects(completeTask({
+        nonce: session.nonce,
+        inputTokens: 1200,
+        outputTokens: 500,
+        durationSeconds: 180,
+        outputHash
+    }), /already been completed/);
+    const repeatedSession = await beginTask({
+        provider: "openai",
+        model: "codex",
+        taskHash,
+        client: "test-client",
+        chainId: 8453,
+        verifyingContract
+    });
+    await assert.rejects(completeTask({
+        nonce: repeatedSession.nonce,
+        inputTokens: 1200,
+        outputTokens: 500,
+        durationSeconds: 180,
+        outputHash
+    }), /Duplicate task\/output evidence/);
+});
+test("derives provider_signed only from a configured valid signature", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "aipou-provider-"));
+    process.env.AIPOU_DATA_DIR = dataDir;
+    process.env.AIPOU_AGENT_PRIVATE_KEY = Wallet.createRandom().privateKey;
+    const pair = generateKeyPairSync("ed25519");
+    const publicKey = pair.publicKey.export({ format: "pem", type: "spki" }).toString();
+    const keyFile = path.join(dataDir, "provider-keys.json");
+    await writeFile(keyFile, JSON.stringify({ local: { "test-key": publicKey } }));
+    process.env.AIPOU_PROVIDER_KEYS_FILE = keyFile;
+    const session = await beginTask({
+        provider: "local",
+        model: "signed-model",
+        taskHash: keccak256(toUtf8Bytes("provider task")),
+        client: "test-client",
+        chainId: 8453,
+        verifyingContract: Wallet.createRandom().address
+    });
+    const completion = {
+        nonce: session.nonce,
+        inputTokens: 2000,
+        outputTokens: 750,
+        durationSeconds: 240,
+        outputHash: keccak256(toUtf8Bytes("provider artifact"))
+    };
+    const signature = sign(null, Buffer.from(canonicalJson(providerAssertion(session, completion))), pair.privateKey).toString("base64");
+    const receipt = await completeTask({
+        ...completion,
+        providerEvidence: { keyId: "test-key", signature }
+    });
+    assert.equal(receipt.trustTier, "provider_signed");
+});
+function fakeReceipt(overrides) {
+    return {
+        receiptId: `0x${"0".repeat(63)}1`,
+        wallet: "0x1111111111111111111111111111111111111111",
+        inputTokens: 1000,
+        outputTokens: 500,
+        recordedAt: new Date().toISOString(),
+        ...overrides
+    };
+}
+test("settlement policy skips tiny receipts and enforces the daily wallet limit", () => {
+    const policy = { minTotalTokens: 200, maxDailyReceiptsPerWallet: 2 };
+    const wallet = "0x1111111111111111111111111111111111111111";
+    const candidates = [
+        fakeReceipt({ receiptId: "0xaaa1", wallet }),
+        fakeReceipt({ receiptId: "0xaaa2", wallet, inputTokens: 50, outputTokens: 20 }),
+        fakeReceipt({ receiptId: "0xaaa3", wallet }),
+        fakeReceipt({ receiptId: "0xaaa4", wallet })
+    ];
+    const alreadySettledToday = [fakeReceipt({ receiptId: "0xbbb1", wallet, claimTransaction: "0xtx" })];
+    const { eligible, skipped } = filterEligibleReceipts(candidates, alreadySettledToday, policy);
+    assert.deepEqual(eligible.map((item) => item.receiptId), ["0xaaa1"]);
+    assert.equal(skipped.length, 3);
+    assert.match(skipped[0].reason, /minimum work floor/);
+    assert.match(skipped[1].reason, /daily receipt limit/);
+    const staleSettled = [
+        fakeReceipt({
+            receiptId: "0xccc1",
+            wallet,
+            claimTransaction: "0xtx",
+            recordedAt: new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString()
+        })
+    ];
+    const fresh = filterEligibleReceipts([fakeReceipt({ receiptId: "0xddd1", wallet })], staleSettled, policy);
+    assert.equal(fresh.eligible.length, 1);
+    const disabled = filterEligibleReceipts(candidates, alreadySettledToday, { minTotalTokens: 0, maxDailyReceiptsPerWallet: 0 });
+    assert.equal(disabled.eligible.length, candidates.length);
+    assert.equal(disabled.skipped.length, 0);
+});
+test("settled receipts move to the archive and stay exportable", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "aipou-archive-"));
+    process.env.AIPOU_DATA_DIR = dataDir;
+    process.env.AIPOU_AGENT_PRIVATE_KEY = Wallet.createRandom().privateKey;
+    const session = await beginTask({
+        provider: "local",
+        model: "archive-model",
+        taskHash: keccak256(toUtf8Bytes("archive task")),
+        client: "test-client",
+        chainId: 8453,
+        verifyingContract: Wallet.createRandom().address
+    });
+    const receipt = await completeTask({
+        nonce: session.nonce,
+        inputTokens: 900,
+        outputTokens: 300,
+        durationSeconds: 60,
+        outputHash: keccak256(toUtf8Bytes("archive output"))
+    });
+    await markBatchSettled({
+        root: `0x${"ab".repeat(32)}`,
+        receiptIds: [receipt.receiptId],
+        publishTransaction: "0xpublish",
+        claimTransaction: "0xclaim",
+        settledAt: new Date().toISOString()
+    });
+    assert.equal((await unsettledReceipts(10)).length, 0);
+    const exported = await exportStoredReceipts();
+    assert.equal(exported.length, 1);
+    assert.equal(exported[0].receiptId, receipt.receiptId);
+    assert.equal(exported[0].claimTransaction, "0xclaim");
+});

package/dist/providers.d.ts

@@ -0,0 +1,3 @@
+import type { CompleteTaskInput, ProviderEvidence, TaskSession, TrustTier } from "./types.js";
+export declare function providerAssertion(session: TaskSession, input: CompleteTaskInput): Record<string, unknown>;
+export declare function deriveTrustTier(session: TaskSession, input: CompleteTaskInput, evidence?: ProviderEvidence): Promise<TrustTier>;

package/dist/providers.js

@@ -0,0 +1,32 @@
+import { verify } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { canonicalJson } from "./canonical.js";
+async function configuredKeys() {
+    const file = process.env.AIPOU_PROVIDER_KEYS_FILE;
+    if (!file)
+        return {};
+    return JSON.parse(await readFile(path.resolve(file), "utf8"));
+}
+export function providerAssertion(session, input) {
+    return {
+        nonce: session.nonce,
+        provider: session.provider,
+        model: session.model,
+        inputTokens: input.inputTokens,
+        outputTokens: input.outputTokens,
+        durationSeconds: input.durationSeconds,
+        outputHash: input.outputHash
+    };
+}
+export async function deriveTrustTier(session, input, evidence) {
+    if (!evidence)
+        return "client_signed";
+    const publicKey = (await configuredKeys())[session.provider]?.[evidence.keyId];
+    if (!publicKey)
+        throw new Error(`No trusted provider key for ${session.provider}/${evidence.keyId}`);
+    const valid = verify(null, Buffer.from(canonicalJson(providerAssertion(session, input))), publicKey, Buffer.from(evidence.signature, "base64"));
+    if (!valid)
+        throw new Error("Invalid provider signature");
+    return "provider_signed";
+}

package/dist/receipts.d.ts

@@ -0,0 +1,11 @@
+import type { CompleteTaskInput, TaskSession, UsageReceipt } from "./types.js";
+export declare function beginTask(input: {
+    provider: string;
+    model: string;
+    taskHash: string;
+    client: string;
+    chainId: number;
+    verifyingContract: string;
+}): Promise<TaskSession>;
+export declare function completeTask(input: CompleteTaskInput): Promise<UsageReceipt>;
+export declare function exportReceipts(wallet?: string): Promise<UsageReceipt[]>;

package/dist/receipts.js

@@ -0,0 +1,53 @@
+import { canonicalJson, sha256Hex } from "./canonical.js";
+import { getCollectorPublicKey, signCollectorPayload } from "./collector.js";
+import { createTaskSession, verifyTaskAuthorization } from "./identity.js";
+import { deriveTrustTier } from "./providers.js";
+import { estimateReward } from "./rewards.js";
+import { exportStoredReceipts, getSession, saveCompletedReceipt, saveSession } from "./store.js";
+export async function beginTask(input) {
+    const session = await createTaskSession(input);
+    await saveSession(session);
+    return session;
+}
+export async function completeTask(input) {
+    const session = await getSession(input.nonce);
+    if (!session)
+        throw new Error("Unknown task nonce");
+    if (session.completedAt)
+        throw new Error("Task nonce has already been completed");
+    if (!verifyTaskAuthorization(session))
+        throw new Error("Invalid EIP-712 wallet authorization");
+    const trustTier = await deriveTrustTier(session, input, input.providerEvidence);
+    const recordedAt = new Date().toISOString();
+    const collectorPublicKey = await getCollectorPublicKey();
+    const unsigned = {
+        nonce: session.nonce,
+        wallet: session.wallet,
+        provider: session.provider,
+        model: session.model,
+        inputTokens: input.inputTokens,
+        outputTokens: input.outputTokens,
+        durationSeconds: input.durationSeconds,
+        taskHash: session.taskHash,
+        outputHash: input.outputHash,
+        client: session.client,
+        trustTier,
+        walletAuthorization: session.walletAuthorization,
+        authorizationIssuedAt: session.issuedAt,
+        authorizationChainId: session.chainId,
+        authorizationContract: session.verifyingContract,
+        providerEvidence: input.providerEvidence,
+        collectorPublicKey,
+        recordedAt,
+        estimatedReward: estimateReward({ ...input, trustTier })
+    };
+    const receiptId = sha256Hex(canonicalJson(unsigned));
+    const collectorSignature = await signCollectorPayload({ receiptId, ...unsigned });
+    const receipt = { receiptId, ...unsigned, collectorSignature };
+    const evidenceKey = sha256Hex(canonicalJson({ taskHash: session.taskHash, outputHash: input.outputHash }));
+    await saveCompletedReceipt(evidenceKey, receipt);
+    return receipt;
+}
+export async function exportReceipts(wallet) {
+    return exportStoredReceipts(wallet);
+}

package/dist/rewards.d.ts

@@ -0,0 +1,7 @@
+import type { TrustTier } from "./types.js";
+export declare function estimateReward(input: {
+    inputTokens: number;
+    outputTokens: number;
+    durationSeconds: number;
+    trustTier: TrustTier;
+}): string;

package/dist/rewards.js

@@ -0,0 +1,12 @@
+const tierMultiplier = {
+    client_signed: 0.75,
+    provider_signed: 1.5
+};
+export function estimateReward(input) {
+    const totalTokens = Math.max(0, input.inputTokens) + Math.max(0, input.outputTokens);
+    const tokenScore = Math.min(totalTokens / 1000, 30);
+    const durationScore = Math.min(Math.max(0, input.durationSeconds) / 300, 12);
+    const rawReward = (tokenScore + durationScore) * tierMultiplier[input.trustTier];
+    const cappedReward = Math.min(rawReward, 50);
+    return cappedReward.toFixed(4);
+}

package/dist/store.d.ts

@@ -0,0 +1,8 @@
+import type { ClaimBatch, TaskSession, UsageReceipt } from "./types.js";
+export declare function saveSession(session: TaskSession): Promise<void>;
+export declare function getSession(nonce: string): Promise<TaskSession | null>;
+export declare function saveCompletedReceipt(evidenceKey: string, receipt: UsageReceipt): Promise<void>;
+export declare function exportStoredReceipts(wallet?: string): Promise<UsageReceipt[]>;
+export declare function unsettledReceipts(limit: number): Promise<UsageReceipt[]>;
+export declare function settledReceiptsSince(sinceMs: number): Promise<UsageReceipt[]>;
+export declare function markBatchSettled(batch: ClaimBatch): Promise<void>;

package/dist/store.js

@@ -0,0 +1,132 @@
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { withFileLock } from "./lock.js";
+const emptyState = () => ({ sessions: {}, receipts: [], completedEvidence: {}, batches: [] });
+let mutationQueue = Promise.resolve();
+function dataDir() {
+    return path.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
+}
+function statePath() {
+    return path.join(dataDir(), "state.json");
+}
+function lockPath() {
+    return `${statePath()}.lock`;
+}
+function archiveDir() {
+    return path.join(dataDir(), "settled");
+}
+async function readState() {
+    try {
+        return JSON.parse(await readFile(statePath(), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyState();
+        throw error;
+    }
+}
+async function writeState(state) {
+    const temporary = `${statePath()}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(temporary, statePath());
+}
+// The in-process queue orders local callers; the file lock orders the multiple
+// MCP server processes (Claude Code, OpenClaw, Codex) that share one data dir.
+// Plain reads stay lock-free: writeState replaces state.json atomically via
+// rename, and every authoritative check re-reads inside mutate().
+async function mutate(operation) {
+    const next = mutationQueue.then(async () => {
+        await mkdir(dataDir(), { recursive: true });
+        return withFileLock(lockPath(), async () => {
+            const state = await readState();
+            const result = await operation(state);
+            await writeState(state);
+            return result;
+        });
+    });
+    mutationQueue = next.catch(() => undefined);
+    return next;
+}
+export async function saveSession(session) {
+    await mutate((state) => {
+        if (state.sessions[session.nonce])
+            throw new Error("Task nonce already exists");
+        state.sessions[session.nonce] = session;
+    });
+}
+export async function getSession(nonce) {
+    return (await readState()).sessions[nonce] || null;
+}
+export async function saveCompletedReceipt(evidenceKey, receipt) {
+    await mutate((state) => {
+        const session = state.sessions[receipt.nonce];
+        if (!session)
+            throw new Error("Unknown task nonce");
+        if (session.completedAt)
+            throw new Error("Task nonce has already been completed");
+        if (state.completedEvidence[evidenceKey]) {
+            throw new Error(`Duplicate task/output evidence already recorded as ${state.completedEvidence[evidenceKey]}`);
+        }
+        if (state.receipts.some((item) => item.receiptId === receipt.receiptId)) {
+            throw new Error("Receipt id has already been recorded");
+        }
+        if ((state.settledReceiptIds ?? []).includes(receipt.receiptId)) {
+            throw new Error("Receipt id has already been settled and archived");
+        }
+        session.completedAt = receipt.recordedAt;
+        state.completedEvidence[evidenceKey] = receipt.receiptId;
+        state.receipts.push(receipt);
+    });
+}
+async function readArchivedReceipts() {
+    let files;
+    try {
+        files = await readdir(archiveDir());
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const receipts = [];
+    for (const file of files.filter((name) => name.endsWith(".json")).sort()) {
+        receipts.push(...JSON.parse(await readFile(path.join(archiveDir(), file), "utf8")));
+    }
+    return receipts;
+}
+export async function exportStoredReceipts(wallet) {
+    const receipts = [...(await readArchivedReceipts()), ...(await readState()).receipts];
+    if (!wallet)
+        return receipts;
+    return receipts.filter((receipt) => receipt.wallet.toLowerCase() === wallet.toLowerCase());
+}
+export async function unsettledReceipts(limit) {
+    return (await readState()).receipts.filter((receipt) => !receipt.claimTransaction).slice(0, limit);
+}
+export async function settledReceiptsSince(sinceMs) {
+    const receipts = [...(await readArchivedReceipts()), ...(await readState()).receipts];
+    return receipts.filter((receipt) => receipt.claimTransaction && Date.parse(receipt.recordedAt) >= sinceMs);
+}
+export async function markBatchSettled(batch) {
+    await mutate(async (state) => {
+        const included = new Set(batch.receiptIds);
+        const settled = [];
+        for (const receipt of state.receipts) {
+            if (included.has(receipt.receiptId)) {
+                if (receipt.claimTransaction)
+                    throw new Error(`Receipt ${receipt.receiptId} is already settled`);
+                receipt.batchRoot = batch.root;
+                receipt.claimTransaction = batch.claimTransaction;
+                settled.push(receipt);
+            }
+        }
+        // Settled receipts move to per-batch archive files so state.json stays
+        // small; their ids stay in state to keep the replay check O(state).
+        await mkdir(archiveDir(), { recursive: true });
+        const archivePath = path.join(archiveDir(), `batch-${batch.root.slice(2, 18)}.json`);
+        await writeFile(archivePath, `${JSON.stringify(settled, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+        state.receipts = state.receipts.filter((receipt) => !included.has(receipt.receiptId));
+        state.settledReceiptIds = [...(state.settledReceiptIds ?? []), ...batch.receiptIds];
+        state.batches.push(batch);
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+export type TrustTier = "client_signed" | "provider_signed";
+export interface TaskSession {
+    nonce: string;
+    wallet: string;
+    provider: string;
+    model: string;
+    taskHash: string;
+    client: string;
+    issuedAt: number;
+    chainId: number;
+    verifyingContract: string;
+    walletAuthorization: string;
+    completedAt?: string;
+}
+export interface ProviderEvidence {
+    keyId: string;
+    signature: string;
+}
+export interface CompleteTaskInput {
+    nonce: string;
+    inputTokens: number;
+    outputTokens: number;
+    durationSeconds: number;
+    outputHash: string;
+    providerEvidence?: ProviderEvidence;
+}
+export interface UsageReceipt {
+    receiptId: string;
+    nonce: string;
+    wallet: string;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    durationSeconds: number;
+    taskHash: string;
+    outputHash: string;
+    client: string;
+    trustTier: TrustTier;
+    walletAuthorization: string;
+    authorizationIssuedAt: number;
+    authorizationChainId: number;
+    authorizationContract: string;
+    providerEvidence?: ProviderEvidence;
+    collectorPublicKey: string;
+    collectorSignature: string;
+    recordedAt: string;
+    estimatedReward: string;
+    batchRoot?: string;
+    claimTransaction?: string;
+}
+export interface ClaimBatch {
+    root: string;
+    receiptIds: string[];
+    publishTransaction: string;
+    claimTransaction: string;
+    settledAt: string;
+}
+export interface SkippedReceipt {
+    receiptId: string;
+    wallet: string;
+    reason: string;
+}
+export interface SettlementResult extends ClaimBatch {
+    skippedReceipts: SkippedReceipt[];
+}
+export interface ProtocolState {
+    sessions: Record<string, TaskSession>;
+    receipts: UsageReceipt[];
+    completedEvidence: Record<string, string>;
+    batches: ClaimBatch[];
+    settledReceiptIds?: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "aipou-mcp-server",
+  "version": "0.2.0",
+  "mcpName": "io.github.0xddneto/ai-proof-of-us",
+  "description": "MCP server for private, signed AI task receipts and optional validated AIPOU claims.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "ai-receipts",
+    "provenance",
+    "base",
+    "aipou"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xddneto/AI-Proof-of-Us.git",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://github.com/0xddneto/AI-Proof-of-Us#readme",
+  "bugs": {
+    "url": "https://github.com/0xddneto/AI-Proof-of-Us/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "bin": {
+    "aipou-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/protocol.test.js",
+    "pack:check": "npm test && npm pack --dry-run",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "dotenv": "^16.6.1",
+    "ethers": "^6.17.0",
+    "merkletreejs": "^0.6.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.4"
+  }
+}