aipou-mcp-server 0.4.0 → 0.6.0

package/dist/store.js

@@ -1,6 +1,9 @@
-import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { withFileLock } from "./lock.js";
+import { isTaskSessionExpired } from "./identity.js";
+import { canonicalJson } from "./canonical.js";
+import { writePrivateJson } from "./private-json.js";
 const emptyState = () => ({ sessions: {}, receipts: [], completedEvidence: {}, batches: [] });
 let mutationQueue = Promise.resolve();
 function dataDir() {
@@ -26,9 +29,7 @@ async function readState() {
     }
 }
 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());
+    await writePrivateJson(statePath(), state);
 }
 // 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.
@@ -63,7 +64,7 @@ export async function saveCompletedReceipt(evidenceKey, receipt) {
         if (!session)
             throw new Error("Unknown task nonce");
         if (session.completedAt)
-            throw new Error("Task nonce has already been completed");
+            throw new Error("Task nonce has already been completed; recover its stored receipt with export_ai_receipts and match the nonce.");
         if (state.completedEvidence[evidenceKey]) {
             throw new Error(`Duplicate task/output evidence already recorded as ${state.completedEvidence[evidenceKey]}`);
         }
@@ -95,7 +96,13 @@ async function readArchivedReceipts() {
     return receipts;
 }
 export async function exportStoredReceipts(wallet) {
-    const receipts = [...(await readArchivedReceipts()), ...(await readState()).receipts];
+    const unique = new Map();
+    for (const receipt of [...(await readState()).receipts, ...(await readArchivedReceipts())]) {
+        const prior = unique.get(receipt.receiptId);
+        if (!prior?.claimTransaction)
+            unique.set(receipt.receiptId, receipt);
+    }
+    const receipts = [...unique.values()];
     if (!wallet)
         return receipts;
     return receipts.filter((receipt) => receipt.wallet.toLowerCase() === wallet.toLowerCase());
@@ -110,15 +117,23 @@ export async function protocolStateCounts() {
         sessions: sessions.length,
         completedSessions: sessions.filter((session) => session.completedAt).length,
         incompleteSessions: sessions.filter((session) => !session.completedAt).length,
+        activeSessions: sessions.filter((session) => !session.completedAt && !isTaskSessionExpired(session)).length,
+        expiredSessions: sessions.filter((session) => !session.completedAt && isTaskSessionExpired(session)).length,
         batches: state.batches.length
     };
 }
 export async function settledReceiptsSince(sinceMs) {
-    const receipts = [...(await readArchivedReceipts()), ...(await readState()).receipts];
+    const receipts = await exportStoredReceipts();
     return receipts.filter((receipt) => receipt.claimTransaction && Date.parse(receipt.recordedAt) >= sinceMs);
 }
 export async function markBatchSettled(batch) {
     await mutate(async (state) => {
+        const existing = state.batches.find(item => item.root === batch.root);
+        if (existing) {
+            if (existing.claimTransaction !== batch.claimTransaction)
+                throw new Error("Settlement archive transaction mismatch");
+            return;
+        }
         const included = new Set(batch.receiptIds);
         const settled = [];
         for (const receipt of state.receipts) {
@@ -133,8 +148,17 @@ export async function markBatchSettled(batch) {
         // 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" });
+        const archivePath = path.join(archiveDir(), `batch-${batch.root.slice(2)}.json`);
+        try {
+            const prior = JSON.parse(await readFile(archivePath, "utf8"));
+            if (canonicalJson(prior) !== canonicalJson(settled))
+                throw new Error("Settlement archive does not match saved batch");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            await writePrivateJson(archivePath, settled);
+        }
         state.receipts = state.receipts.filter((receipt) => !included.has(receipt.receiptId));
         state.settledReceiptIds = [...(state.settledReceiptIds ?? []), ...batch.receiptIds];
         state.batches.push(batch);

package/dist/technocore-link.d.ts

@@ -0,0 +1,34 @@
+export declare const TECHNOCORE_TRANSPORT_SCHEME = "technocore-room-receipt-v1";
+export declare const EXTERNAL_EVIDENCE_LINK_SCHEME = "external-evidence-link-v1";
+export type TechnocoreWorkLinkInput = {
+    workReceiptId: string;
+    transportArtifactId: string;
+    transportArtifactDigest: string;
+    issuedAt: string;
+};
+export type TechnocoreWorkLink = {
+    scheme: typeof EXTERNAL_EVIDENCE_LINK_SCHEME;
+    /** Stable logical identity that excludes issuedAt for retry-safe deduplication. */
+    linkId: string;
+    relation: "supports";
+    source: {
+        kind: "receipt";
+        scheme: "aipou-receipt-v1";
+        id: string;
+        digest: string;
+    };
+    target: {
+        kind: "transport-record";
+        scheme: typeof TECHNOCORE_TRANSPORT_SCHEME;
+        id: string;
+        digest: string;
+    };
+    privacy: "digest_only";
+    issuedAt: string;
+    linkDigest: string;
+};
+/**
+ * Creates a digest-only correlation artifact. It never calls Technocore or
+ * upgrades a supplied snapshot into verified signed transport evidence.
+ */
+export declare function createTechnocoreWorkLink(input: TechnocoreWorkLinkInput): TechnocoreWorkLink;

package/dist/technocore-link.js

@@ -0,0 +1,49 @@
+import { canonicalJson, sha256Hex } from "./canonical.js";
+export const TECHNOCORE_TRANSPORT_SCHEME = "technocore-room-receipt-v1";
+export const EXTERNAL_EVIDENCE_LINK_SCHEME = "external-evidence-link-v1";
+const receiptIdPattern = /^0x[0-9a-f]{64}$/;
+const sha256Pattern = /^sha256:[0-9a-f]{64}$/;
+function assertValidInput(input) {
+    if (!receiptIdPattern.test(input.workReceiptId)) {
+        throw new Error("workReceiptId must be a lowercase 0x-prefixed SHA-256 identifier");
+    }
+    if (!sha256Pattern.test(input.transportArtifactDigest)) {
+        throw new Error("transportArtifactDigest must be a lowercase sha256 digest");
+    }
+    if (input.transportArtifactId.length < 1 || input.transportArtifactId.length > 256) {
+        throw new Error("transportArtifactId must be an opaque reference between 1 and 256 characters");
+    }
+    if (!Number.isFinite(Date.parse(input.issuedAt))) {
+        throw new Error("issuedAt must be an ISO-8601 timestamp");
+    }
+}
+/**
+ * Creates a digest-only correlation artifact. It never calls Technocore or
+ * upgrades a supplied snapshot into verified signed transport evidence.
+ */
+export function createTechnocoreWorkLink(input) {
+    assertValidInput(input);
+    const identity = {
+        scheme: EXTERNAL_EVIDENCE_LINK_SCHEME,
+        relation: "supports",
+        source: {
+            kind: "receipt",
+            scheme: "aipou-receipt-v1",
+            id: input.workReceiptId,
+            digest: `sha256:${input.workReceiptId.slice(2)}`
+        },
+        target: {
+            kind: "transport-record",
+            scheme: TECHNOCORE_TRANSPORT_SCHEME,
+            id: input.transportArtifactId,
+            digest: input.transportArtifactDigest
+        },
+        privacy: "digest_only"
+    };
+    const payload = { ...identity, issuedAt: input.issuedAt };
+    return {
+        ...payload,
+        linkId: `sha256:${sha256Hex(canonicalJson(identity)).slice(2)}`,
+        linkDigest: `sha256:${sha256Hex(canonicalJson(payload)).slice(2)}`
+    };
+}

package/dist/technocore-link.test.d.ts

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

package/dist/technocore-link.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTechnocoreWorkLink } from "./technocore-link.js";
+const input = {
+    workReceiptId: `0x${"ab".repeat(32)}`,
+    transportArtifactId: "technocore:lobby:receipt-synthetic-001",
+    transportArtifactDigest: `sha256:${"cd".repeat(32)}`,
+    issuedAt: "2026-08-26T14:30:00.000Z"
+};
+test("creates a digest-only Technocore to AIPOU work link without transport authority", () => {
+    const link = createTechnocoreWorkLink(input);
+    assert.equal(link.scheme, "external-evidence-link-v1");
+    assert.equal(link.relation, "supports");
+    assert.equal(link.source.id, input.workReceiptId);
+    assert.equal(link.target.scheme, "technocore-room-receipt-v1");
+    assert.equal(link.target.id, input.transportArtifactId);
+    assert.equal(link.target.digest, input.transportArtifactDigest);
+    assert.match(link.linkId, /^sha256:[0-9a-f]{64}$/);
+    assert.match(link.linkDigest, /^sha256:[0-9a-f]{64}$/);
+    assert.equal("did" in link, false);
+    assert.equal("signature" in link, false);
+    assert.equal("deliveryStatus" in link, false);
+    assert.equal("claimStatus" in link, false);
+});
+test("is deterministic and changes when the transport artifact changes", () => {
+    assert.equal(createTechnocoreWorkLink(input).linkDigest, createTechnocoreWorkLink(input).linkDigest);
+    assert.equal(createTechnocoreWorkLink(input).linkId, createTechnocoreWorkLink({ ...input, issuedAt: "2026-08-26T15:30:00.000Z" }).linkId);
+    assert.notEqual(createTechnocoreWorkLink(input).linkDigest, createTechnocoreWorkLink({ ...input, issuedAt: "2026-08-26T15:30:00.000Z" }).linkDigest);
+    assert.notEqual(createTechnocoreWorkLink(input).linkId, createTechnocoreWorkLink({ ...input, transportArtifactDigest: `sha256:${"ef".repeat(32)}` }).linkId);
+});
+test("rejects malformed receipt, digest, opaque reference, and timestamp inputs", () => {
+    assert.throws(() => createTechnocoreWorkLink({ ...input, workReceiptId: "0xabc" }));
+    assert.throws(() => createTechnocoreWorkLink({ ...input, transportArtifactDigest: "sha256:ABC" }));
+    assert.throws(() => createTechnocoreWorkLink({ ...input, transportArtifactId: "" }));
+    assert.throws(() => createTechnocoreWorkLink({ ...input, issuedAt: "not-a-date" }));
+});

package/dist/tool-metadata.test.d.ts

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

package/dist/tool-metadata.test.js

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+test("tool metadata explains parameters, side effects, and safe alternatives", async () => {
+    const transport = new StdioClientTransport({
+        command: process.execPath,
+        args: [fileURLToPath(new URL("./index.js", import.meta.url))],
+        stderr: "pipe"
+    });
+    const client = new Client({ name: "aipou-tool-metadata-test", version: "1.0.0" });
+    await client.connect(transport);
+    try {
+        const { tools } = await client.listTools();
+        const complete = tools.find((tool) => tool.name === "complete_ai_task");
+        const estimate = tools.find((tool) => tool.name === "estimate_ai_reward");
+        const status = tools.find((tool) => tool.name === "get_aipou_status");
+        const begin = tools.find((tool) => tool.name === "begin_ai_task");
+        const paybox = tools.find((tool) => tool.name === "create_paybox_work_link");
+        const technocore = tools.find((tool) => tool.name === "create_technocore_work_link");
+        const verifyReceipt = tools.find((tool) => tool.name === "verify_aipou_receipt");
+        const settleAll = tools.find((tool) => tool.name === "settle_all_ai_rewards");
+        assert.ok(complete);
+        assert.match(complete.description ?? "", /once after begin_ai_task/i);
+        assert.match(complete.description ?? "", /writes the local receipt store/i);
+        assert.match(complete.description ?? "", /does not .*submit a blockchain transaction/i);
+        assert.match(complete.description ?? "", /workReceiptId/i);
+        assert.match(complete.description ?? "", /get_aipou_status/i);
+        assert.deepEqual(complete.annotations, {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        });
+        const completeProperties = complete.inputSchema.properties;
+        for (const field of ["nonce", "inputTokens", "outputTokens", "durationSeconds", "outputHash"]) {
+            assert.ok(completeProperties[field]?.description, `${field} must have a description`);
+        }
+        assert.ok(completeProperties.providerEvidence?.description);
+        assert.ok(completeProperties.providerEvidence?.properties?.keyId?.description);
+        assert.ok(completeProperties.providerEvidence?.properties?.signature?.description);
+        assert.ok(estimate);
+        assert.match(estimate.description ?? "", /informational/i);
+        assert.match(estimate.description ?? "", /inputTokens, outputTokens, and durationSeconds/i);
+        assert.equal(estimate.annotations?.readOnlyHint, true);
+        assert.equal(estimate.annotations?.idempotentHint, true);
+        assert.ok(status);
+        assert.match(status.description ?? "", /read-only JSON summary/i);
+        assert.match(status.description ?? "", /never signs or submits a transaction/i);
+        assert.match(status.description ?? "", /explicit claim request/i);
+        assert.equal(status.annotations?.readOnlyHint, true);
+        assert.equal(status.annotations?.openWorldHint, true);
+        assert.ok(begin);
+        assert.match(begin.description ?? "", /writes a pending local task session/i);
+        assert.match(begin.description ?? "", /does not publish, mint, or submit an on-chain transaction/i);
+        assert.equal(begin.annotations?.readOnlyHint, false);
+        assert.equal(begin.annotations?.idempotentHint, false);
+        const beginProperties = begin.inputSchema.properties;
+        for (const field of ["provider", "model", "taskHash", "client"]) {
+            assert.ok(beginProperties[field]?.description, `${field} must have a description`);
+        }
+        for (const tool of [paybox, technocore]) {
+            assert.ok(tool);
+            assert.match(tool.description ?? "", /pure local calculation/i);
+            assert.match(tool.description ?? "", /does not persist/i);
+            assert.equal(tool.annotations?.readOnlyHint, true);
+            assert.equal(tool.annotations?.idempotentHint, true);
+        }
+        assert.ok(verifyReceipt);
+        assert.match(verifyReceipt.description ?? "", /self-contained integrity/i);
+        assert.match(verifyReceipt.description ?? "", /does not .*prove delivery/i);
+        assert.equal(verifyReceipt.annotations?.readOnlyHint, true);
+        assert.equal(verifyReceipt.annotations?.idempotentHint, true);
+        assert.ok(settleAll);
+        assert.match(settleAll.description ?? "", /explicit broad request/i);
+        assert.equal(settleAll.annotations?.readOnlyHint, false);
+        assert.equal(settleAll.annotations?.openWorldHint, true);
+        const settleAllProperties = settleAll.inputSchema.properties;
+        assert.ok(settleAllProperties.batchSize?.description);
+        assert.ok(settleAllProperties.maxBatches?.description);
+    }
+    finally {
+        await transport.close();
+    }
+});

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 export type TrustTier = "client_signed" | "provider_signed";
+export type TokenUsageMeasurement = "measured" | "unmeasured" | "unspecified";
 export interface TaskSession {
     nonce: string;
     wallet: string;
@@ -7,6 +8,8 @@ export interface TaskSession {
     taskHash: string;
     client: string;
     issuedAt: number;
+    /** Unix seconds. A pending session is not authority to complete after this point. */
+    expiresAt?: number;
     chainId: number;
     verifyingContract: string;
     walletAuthorization: string;
@@ -17,6 +20,7 @@ export interface ProviderEvidence {
     signature: string;
 }
 export interface CompleteTaskInput {
+    tokenUsageMeasurement?: TokenUsageMeasurement;
     nonce: string;
     inputTokens: number;
     outputTokens: number;
@@ -25,6 +29,8 @@ export interface CompleteTaskInput {
     providerEvidence?: ProviderEvidence;
 }
 export interface UsageReceipt {
+    /** Absent on legacy signed receipts; absence never implies measured usage. */
+    tokenUsageMeasurement?: TokenUsageMeasurement;
     receiptId: string;
     nonce: string;
     wallet: string;

package/dist/usage-recovery.test.d.ts

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

package/dist/usage-recovery.test.js

@@ -0,0 +1,121 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { Wallet } from "ethers";
+import { canonicalJson, sha256Hex } from "./canonical.js";
+import { signCollectorPayload } from "./collector.js";
+import { localFeedbackSummary } from "./feedback.js";
+import { beginTask, completeTask, exportReceipts } from "./receipts.js";
+import { verifyAipouReceipt } from "./receipt-verifier.js";
+import { markBatchSettled, unsettledReceipts } from "./store.js";
+test("unmeasured zero differs from measured zero and recovered receipts are not duplicated", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "aipou-usage-"));
+    process.env.AIPOU_DATA_DIR = dir;
+    process.env.AIPOU_AGENT_PRIVATE_KEY = Wallet.createRandom().privateKey;
+    try {
+        const create = (s) => beginTask({
+            provider: "local",
+            model: "test",
+            client: "test",
+            taskHash: sha256Hex(s),
+            chainId: 8453,
+            verifyingContract: Wallet.createRandom().address,
+        });
+        const one = await create("one");
+        await assert.rejects(completeTask({
+            nonce: one.nonce,
+            inputTokens: 1,
+            outputTokens: 0,
+            durationSeconds: 1,
+            outputHash: sha256Hex("out"),
+            tokenUsageMeasurement: "unmeasured",
+        }), /zero counts/);
+        const receipt = await completeTask({
+            nonce: one.nonce,
+            inputTokens: 0,
+            outputTokens: 0,
+            durationSeconds: 1,
+            outputHash: sha256Hex("out"),
+            tokenUsageMeasurement: "unmeasured",
+        });
+        assert.equal(receipt.tokenUsageMeasurement, "unmeasured");
+        assert.equal(verifyAipouReceipt(receipt).valid, true);
+        const { tokenUsageMeasurement: _measurement, receiptId: _id, collectorSignature: _signature, ...legacyUnsigned } = receipt;
+        const legacyId = sha256Hex(canonicalJson(legacyUnsigned));
+        const legacy = {
+            receiptId: legacyId,
+            ...legacyUnsigned,
+            collectorSignature: await signCollectorPayload({
+                receiptId: legacyId,
+                ...legacyUnsigned,
+            }),
+        };
+        assert.equal(verifyAipouReceipt(legacy).valid, true, "legacy receipts remain valid without the new optional field");
+        await assert.rejects(completeTask({
+            nonce: one.nonce,
+            inputTokens: 0,
+            outputTokens: 0,
+            durationSeconds: 1,
+            outputHash: receipt.outputHash,
+        }), /export_ai_receipts/);
+        assert.equal((await exportReceipts()).find((r) => r.nonce === one.nonce)?.receiptId, receipt.receiptId);
+        const two = await create("two");
+        const measured = await completeTask({
+            nonce: two.nonce,
+            inputTokens: 0,
+            outputTokens: 0,
+            durationSeconds: 1,
+            outputHash: sha256Hex("out2"),
+            tokenUsageMeasurement: "measured",
+        });
+        assert.equal(measured.tokenUsageMeasurement, "measured");
+        const three = await create("three");
+        const unspecified = await completeTask({
+            nonce: three.nonce,
+            inputTokens: 0,
+            outputTokens: 0,
+            durationSeconds: 1,
+            outputHash: sha256Hex("out3"),
+        });
+        assert.equal(unspecified.tokenUsageMeasurement, "unspecified");
+        const feedback = await localFeedbackSummary();
+        assert.equal(feedback.localReceiptCount, 3);
+        assert.equal(feedback.measuredUsageReceipts, 1);
+        assert.equal(feedback.unmeasuredUsageReceipts, 1);
+        assert.equal(feedback.unspecifiedUsageReceipts, 1);
+        const text = JSON.stringify(feedback);
+        assert.ok(!text.includes(receipt.receiptId));
+        assert.ok(!text.includes(receipt.wallet));
+        assert.ok(!text.includes(dir));
+        // Simulate archive written but state update interrupted; recovery is idempotent.
+        const batch = {
+            root: sha256Hex("batch"),
+            receiptIds: [receipt.receiptId],
+            publishTransaction: "0xpublish",
+            claimTransaction: "0xclaim",
+            settledAt: new Date().toISOString(),
+        };
+        await mkdir(path.join(dir, "settled"), { recursive: true });
+        await writeFile(path.join(dir, "settled", `batch-${batch.root.slice(2)}.json`), JSON.stringify([
+            {
+                ...receipt,
+                batchRoot: batch.root,
+                claimTransaction: batch.claimTransaction,
+            },
+        ]));
+        await markBatchSettled(batch);
+        await markBatchSettled(batch);
+        assert.equal((await unsettledReceipts(100)).length, 2);
+        assert.equal((await exportReceipts()).filter((r) => r.receiptId === receipt.receiptId)
+            .length, 1);
+        assert.equal(JSON.parse(await readFile(path.join(dir, "state.json"), "utf8")).batches
+            .length, 1);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+        delete process.env.AIPOU_DATA_DIR;
+        delete process.env.AIPOU_AGENT_PRIVATE_KEY;
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aipou-mcp-server",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "mcpName": "io.github.0xddneto/ai-proof-of-us",
   "description": "MCP server for private, signed AI task receipts and optional validated AIPOU claims.",
   "author": "0xddneto",
@@ -29,14 +29,15 @@
   "files": [
     "dist",
     "README.md",
+    "NOTICE",
     "server.json"
   ],
   "bin": {
     "aipou-mcp": "dist/index.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test dist/protocol.test.js dist/rewards.test.js dist/canonical.test.js dist/demo.test.js dist/init.test.js dist/version.test.js",
+    "build": "tsc -p tsconfig.json && esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --external:dotenv --external:dotenv/* --external:ethers --external:merkletreejs --external:zod --external:zod/*",
+    "test": "npm run build && node --test dist/*.test.js",
     "pack:check": "npm test && npm pack --dry-run",
     "demo": "npm run build && node dist/index.js --demo",
     "dev": "tsx src/index.ts",
@@ -50,14 +51,15 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.13.0",
     "dotenv": "^16.6.1",
     "ethers": "^6.17.0",
     "merkletreejs": "^0.6.0",
-    "zod": "^3.23.8"
+    "zod": "^4.6.7"
   },
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "1.32.2",
     "@types/node": "^22.5.4",
+    "esbuild": "0.28.1",
     "tsx": "^4.19.0",
     "typescript": "^5.5.4"
   }

package/server.json

@@ -9,12 +9,12 @@
     "source": "github",
     "subfolder": "mcp-server"
   },
-  "version": "0.4.0",
+  "version": "0.6.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "aipou-mcp-server",
-      "version": "0.4.0",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       },