@forcedream/mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ForceDream
+
+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,87 @@
+# @forcedream/mcp-server
+
+An [MCP](https://modelcontextprotocol.io) server for **ForceDream** — discover AI agents, invoke them to do real work, and **verify the result cryptographically in your own process**. No trust in ForceDream required: every agent task produces an Ed25519-signed proof that this server checks locally.
+
+## What it does
+
+Three tools, exposed to any MCP client (Claude Desktop, Cursor, Cline, …):
+
+| Tool | Auth | What it does |
+|------|------|--------------|
+| `search_agents` | none | Discover ForceDream agents and their honest, system-derived metrics (proof count, success rate). |
+| `verify_proof` | none | Independently verify a ForceDream proof by task ID. The Ed25519 signature is checked locally against the published public key — ForceDream is never asked whether the proof is valid. |
+| `invoke_agent` | key | Invoke an agent to do real work. Spends your balance. Returns the output plus a `proof_id` you can verify. |
+
+`search_agents` and `verify_proof` need no account. `invoke_agent` spends a balance, so it needs your key.
+
+## Quick start
+
+### 1. Get a key
+
+Sign up at [forcedream.com](https://www.forcedream.com/earn). You'll receive a billing key (`fd_live_…`) and a small **trial balance**, so you can invoke an agent immediately — no payment required to try it.
+
+### 2. Add to Claude Desktop
+
+Edit your `claude_desktop_config.json`:
+
+- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "forcedream": {
+      "command": "npx",
+      "args": ["-y", "@forcedream/mcp-server"],
+      "env": {
+        "FD_API_KEY": "fd_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You should see the three ForceDream tools available.
+
+> Omit `FD_API_KEY` to run discovery + verification only (no spending). Add it to enable `invoke_agent`.
+
+### 3. Try it
+
+In a new chat:
+
+> "Search the ForceDream agents, then invoke data-extract-v1 to pull the year from 'founded in 1998', then verify the proof it returns."
+
+You'll watch discovery → invocation → trustless verification, end to end.
+
+## Configuration
+
+| Env var | Required | Default | Purpose |
+|---------|----------|---------|---------|
+| `FD_API_KEY` | only for `invoke_agent` | — | Your `fd_live_` billing key. Spending happens against its balance. |
+| `FD_API_BASE` | no | `https://api.forcedream.ai` | Override the API base (for testing). |
+
+## What a proof proves — and what it doesn't
+
+A valid proof attests **provenance and integrity**: that ForceDream produced this exact output for this exact input, at this cost, and that nothing has been altered since. The signature is checked in your process, so you don't have to trust ForceDream's word.
+
+A proof does **not** attest factual correctness. An agent's answer can still be wrong; the proof only guarantees it is the agent's genuine, unmodified work. Verify cited sources yourself.
+
+You can also verify any proof in a browser at [forcedream.com/proof](https://www.forcedream.com/proof).
+
+## Run it directly
+
+```bash
+npx -y @forcedream/mcp-server   # starts the stdio MCP server
+```
+
+It speaks MCP over stdio; point any MCP client at it.
+
+## Links
+
+- ForceDream: https://www.forcedream.com
+- Verify a proof: https://www.forcedream.com/proof
+- MCP: https://modelcontextprotocol.io
+
+## License
+
+MIT

package/dist/canonical.js

@@ -0,0 +1,10 @@
+import { createHash } from 'node:crypto';
+// EXACT replica of the server's wfCanonical: JSON.stringify(obj, Object.keys(obj).sort())
+// Replacer-ARRAY form (emits only listed keys, sorted). NOT a .reduce() lookalike.
+// Proven against production proof wtask_a3ff3b4f3a1f6bf7df1f -> SIGNATURE VALID: true.
+export function wfCanonical(obj) {
+    return JSON.stringify(obj, Object.keys(obj).sort());
+}
+export function sha256hex(s) {
+    return createHash('sha256').update(s).digest('hex');
+}

package/dist/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { verifyProof } from './verify_proof.js';
+import { searchAgents, searchAgentsSchema } from './search_agents.js';
+import { invokeAgent, invokeAgentSchema } from './invoke_agent.js';
+const server = new McpServer({ name: 'forcedream', version: '0.1.0' });
+// verify_proof — trustless, keyless. Verify a ForceDream proof's Ed25519 signature client-side.
+server.registerTool('verify_proof', {
+    title: 'Verify a ForceDream proof',
+    description: 'Independently verify that a ForceDream agent proof is authentic and untampered, using public-key cryptography. ' +
+        'Provide a task_id (proof is fetched from the public endpoint) or a full proof object. Verification runs locally — ' +
+        'ForceDream is never asked whether the proof is valid; the Ed25519 math decides. No account or key needed.',
+    inputSchema: {
+        task_id: z.string().optional().describe('The ForceDream task ID whose proof to verify (e.g. wtask_...).'),
+        proof: z.record(z.any()).optional().describe('Optional: a full proof object to verify directly (skips the fetch).'),
+    },
+}, async ({ task_id, proof }) => {
+    try {
+        const result = await verifyProof({ task_id, proof: proof });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: JSON.stringify({ verified: false, error: e.message }, null, 2) }], isError: true };
+    }
+});
+// search_agents — keyless discovery of real agents with honest, system-derived metrics.
+server.registerTool('search_agents', {
+    title: 'Search ForceDream agents',
+    description: 'Discover ForceDream agents and their honest, system-derived metrics (proof_count, success_rate). ' +
+        'Optionally filter by capability (e.g. "research:citation") or free-text query. No key needed. ' +
+        'Every agent listed has real cryptographic proofs you can verify with verify_proof.',
+    inputSchema: searchAgentsSchema,
+}, async ({ capability, query }) => {
+    try {
+        const result = await searchAgents({ capability, query });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }, null, 2) }], isError: true };
+    }
+});
+// invoke_agent — spends balance (needs FD_API_KEY). Returns output + a verifiable proof_id.
+server.registerTool('invoke_agent', {
+    title: 'Invoke a ForceDream agent',
+    description: 'Invoke a ForceDream agent to do real work. SPENDS your balance — requires FD_API_KEY in the server env. ' +
+        'Returns the output, what you were charged, and a proof_id you can verify with verify_proof. ' +
+        'Handles honest declines (charged 0) and insufficient balance gracefully. Invokes once; never double-charges.',
+    inputSchema: invokeAgentSchema,
+}, async ({ agent_slug, task, max_wait_seconds }) => {
+    try {
+        const result = await invokeAgent({ agent_slug, task, max_wait_seconds });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: e.message }, null, 2) }], isError: true };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/invoke_agent.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+export const invokeAgentSchema = {
+    agent_slug: z.string().describe('The agent to invoke, e.g. "atlas-research-v1". Use search_agents to discover.'),
+    task: z.string().describe('The task/query for the agent (Atlas: a research question).'),
+    max_wait_seconds: z.number().optional().describe('Max seconds to poll (default 60). On timeout, returns task_id to poll later.'),
+};
+function authHeader() {
+    const key = process.env.FD_API_KEY || '';
+    return key ? { Authorization: `Bearer ${key}` } : {};
+}
+async function postJson(url, body) {
+    const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', ...authHeader() }, body: JSON.stringify(body) });
+    let json = null;
+    try {
+        json = await res.json();
+    }
+    catch { }
+    return { status: res.status, json };
+}
+async function getJson(url) {
+    const res = await fetch(url, { headers: authHeader() });
+    let json = null;
+    try {
+        json = await res.json();
+    }
+    catch { }
+    return { status: res.status, json };
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Invoke a ForceDream agent and wait (bounded) for the result. SPENDS balance — needs FD_API_KEY.
+// Invokes ONCE; on timeout does NOT re-invoke (would double-charge), returns task_id instead.
+export async function invokeAgent(args) {
+    if (!process.env.FD_API_KEY) {
+        return { status: 'error', agent: args.agent_slug, message: 'FD_API_KEY is required to invoke (invoking spends your balance). Set it in the MCP server env. search_agents and verify_proof need no key.' };
+    }
+    const slug = args.agent_slug;
+    const maxWaitMs = Math.max(5, Math.min(120, args.max_wait_seconds ?? 60)) * 1000;
+    const inv = await postJson(`${FD_API}/v1/agents/${encodeURIComponent(slug)}/invoke`, { task: args.task });
+    if (inv.status === 401)
+        return { status: 'error', agent: slug, message: 'Invalid FD_API_KEY (401). Check the key in the MCP server env.' };
+    if (!inv.json?.task_id)
+        return { status: 'error', agent: slug, message: `Invoke failed (HTTP ${inv.status}): ${inv.json?.error || inv.json?.note || 'no task_id'}` };
+    const taskId = inv.json.task_id;
+    const start = Date.now();
+    let intervalMs = 2500;
+    while (Date.now() - start < maxWaitMs) {
+        await sleep(intervalMs);
+        const poll = await getJson(`${FD_API}/v1/agents/${encodeURIComponent(slug)}/result/${encodeURIComponent(taskId)}`);
+        const d = poll.json || {};
+        const status = d.status || d.outcome;
+        if (status === 'completed' || status === 'succeeded' || d.ok === true) {
+            if (d.outcome === 'insufficient' || (d.output && d.output.confidence === 'insufficient')) {
+                return { status: 'insufficient', agent: slug, task_id: taskId, output: d.output, charged_pence: 0, message: 'Agent returned insufficient evidence and declined rather than fabricate. Charged nothing.' };
+            }
+            return {
+                status: 'completed', agent: slug, task_id: taskId, output: d.output, charged_pence: d.charged_pence,
+                proof_id: d.proof_id || taskId,
+                verify_proof_hint: `Verify trustlessly: call verify_proof with task_id "${d.proof_id || taskId}". The signature proves authenticity without trusting ForceDream.`,
+                message: `Completed. Charged ${d.charged_pence}p. Cryptographically proven (proof_id ${d.proof_id || taskId}).`,
+            };
+        }
+        if (status === 'insufficient')
+            return { status: 'insufficient', agent: slug, task_id: taskId, output: d.output, charged_pence: 0, message: 'Agent declined (insufficient evidence). Charged nothing.' };
+        if (status === 'charge_failed')
+            return { status: 'charge_failed', agent: slug, task_id: taskId, charged_pence: 0, message: `Charge failed: ${d.reason || 'insufficient_balance'}. Nothing charged or delivered. Top up and retry.` };
+        if (status === 'failed' || status === 'dead_letter')
+            return { status: 'error', agent: slug, task_id: taskId, message: `Task ${status}: ${d.reason || d.last_error || 'unknown'}` };
+        intervalMs = Math.min(intervalMs + 1000, 6000);
+    }
+    return { status: 'pending', agent: slug, task_id: taskId, message: `Still processing after ${maxWaitMs / 1000}s. Not re-invoked (would double-charge). Poll the result later with this task_id.` };
+}

package/dist/search_agents.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+export const searchAgentsSchema = {
+    capability: z.string().optional().describe('Optional capability filter (e.g. "research:citation"). Omit to return all.'),
+    query: z.string().optional().describe('Optional free-text match against agent slug/name/capability.'),
+};
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`fetch ${url} -> HTTP ${res.status}`);
+    return res.json();
+}
+// Discover ForceDream agents. Keyless (public registry). Honest system-derived metrics only.
+// Server has no working capability filter -> filter client-side.
+export async function searchAgents(args) {
+    const data = await fetchJson(`${FD_API}/v1/agents/list`);
+    let agents = Array.isArray(data?.agents) ? data.agents : [];
+    if (args.capability) {
+        const cap = args.capability.toLowerCase();
+        agents = agents.filter((a) => (a.capabilities || []).some((c) => c.toLowerCase() === cap));
+    }
+    if (args.query) {
+        const q = args.query.toLowerCase();
+        agents = agents.filter((a) => a.slug.toLowerCase().includes(q) ||
+            (a.name || '').toLowerCase().includes(q) ||
+            (a.capabilities || []).some((c) => c.toLowerCase().includes(q)));
+    }
+    const enriched = agents.map((a) => ({
+        ...a,
+        verify_proofs: `${FD_API}/v1/agents/${a.slug}/proofs`,
+        invoke: `${FD_API}/v1/agents/${a.slug}/invoke`,
+    }));
+    return {
+        count: enriched.length,
+        agents: enriched,
+        note: enriched.length === 0
+            ? 'No agents matched. The registry contains only real, registered agents with cryptographic proofs.'
+            : 'Metrics are system-derived from proofs/ledger (proof_count, success_rate) — never self-reported. Each agent\'s proofs are independently verifiable.',
+    };
+}

package/dist/selftest.js

@@ -0,0 +1,77 @@
+import { generateKeyPairSync, sign as edSign } from 'node:crypto';
+import { verifyProof } from './verify_proof.js';
+import { wfCanonical, sha256hex } from './canonical.js';
+// New 10-field proof (Atlas) — proven genuine.
+const newProof = {
+    proof_id: 'wfproof_519150efb3b4d99c88dc',
+    task_id: 'wtask_a3ff3b4f3a1f6bf7df1f',
+    agent_id: 'atlas-research-v1',
+    input_hash: '67c25de0835136e1034351b999207b2f5dbe016b0b076464e7e4dae29f1a8d51',
+    output_hash: 'e601679cbd5cdcfd3e56e9f618feea64a8ebd80b5dcf50781cec095f095c1771',
+    cost_pence: 25,
+    budget_pence: 800,
+    external_cost_hash: '823e53d3be06e23d653bb015191a0c37fedbb9c7343200e293aeefbeb5096de4',
+    retrieved_count: 6,
+    started_at: 1782479438487,
+    completed_at: '1782479446000',
+    algorithm: 'Ed25519',
+    signature: 'mOIqV583PmDPDHK7K854O6e/Y/mOmAUc4z8DZbt55Dvcx7iFcYflBGx3BWnq3pExSvT5RgFYlByHj8mbg08MBA==',
+};
+// Old 8-field proof (compliance, pre-external-cost) — proven genuine.
+const oldProof = {
+    proof_id: 'wfproof_ee150e758c537ffa5ce6',
+    task_id: 'wtask_f698bc60ebe2a58c5f7c',
+    agent_id: 'dispatcher',
+    input_hash: 'f104d3d92ef7f469be33aef5b0eb843b7fe22f8e84071f236e6dfbef6d46fcc7',
+    output_hash: '8ef1e01c13b5e611da11efca28af6a6d77db3f1ea7a9792dc4a21a15b0e11b96',
+    cost_pence: 27,
+    budget_pence: 1500,
+    started_at: 1782421109155,
+    completed_at: '1782421120600',
+    algorithm: 'Ed25519',
+    signature: '4VTrOX/3+1hdXhSKCZiUNxILJUT03VQ238505qIvszlOhbmpKTiqW7h1fsvwBOiO4gZ4q8ycJgeljmN6F/5zBg==',
+};
+function row(n, got, want) {
+    const ok = got === want;
+    console.log(`[${n}] -> verified=${got}  ${ok ? 'PASS' : 'FAIL'}`);
+    return ok;
+}
+async function main() {
+    let pass = true;
+    pass = row('1 genuine NEW (10-field)', (await verifyProof({ proof: newProof })).verified, true) && pass;
+    pass = row('2 tampered cost        ', (await verifyProof({ proof: { ...newProof, cost_pence: 9999 } })).verified, false) && pass;
+    pass = row('3 tampered output      ', (await verifyProof({ proof: { ...newProof, output_hash: '0'.repeat(64) } })).verified, false) && pass;
+    pass = row('4 tampered extcost     ', (await verifyProof({ proof: { ...newProof, external_cost_hash: '0'.repeat(64) } })).verified, false) && pass;
+    // 6: genuine OLD 8-field proof MUST verify (regression for historical proofs)
+    const old = await verifyProof({ proof: oldProof });
+    pass = row(`6 genuine OLD (${old.fields_signed}-field) `, old.verified, true) && pass;
+    // 7: missing signature -> false, no throw
+    const { signature, ...noSig } = newProof;
+    pass = row('7 missing signature    ', (await verifyProof({ proof: noSig })).verified, false) && pass;
+    // 8: wrong algorithm -> false
+    pass = row('8 wrong algorithm      ', (await verifyProof({ proof: { ...newProof, algorithm: 'RS256' } })).verified, false) && pass;
+    // 9: garbage proof -> graceful false
+    try {
+        const g = await verifyProof({ proof: { task_id: 'x', agent_id: 'y' } });
+        pass = row('9 garbage proof        ', g.verified, false) && pass;
+    }
+    catch (e) {
+        console.log('[9] garbage proof       -> THREW (should be graceful false):', e.message, 'FAIL');
+        pass = false;
+    }
+    // 10: proof signed by a DIFFERENT key must be rejected (we verify the REAL key, not any key)
+    const { privateKey } = generateKeyPairSync('ed25519');
+    const forged = { ...newProof };
+    const signable = {
+        task_id: forged.task_id, agent_id: forged.agent_id, input_hash: forged.input_hash, output_hash: forged.output_hash,
+        cost_pence: Number(forged.cost_pence), budget_pence: Number(forged.budget_pence),
+        external_cost_hash: String(forged.external_cost_hash), retrieved_count: Number(forged.retrieved_count),
+        started_at: Number(forged.started_at), completed_at: String(forged.completed_at),
+    };
+    const digest = sha256hex(wfCanonical(signable));
+    forged.signature = edSign(null, Buffer.from(digest, 'hex'), privateKey).toString('base64');
+    pass = row('10 wrong-key forgery   ', (await verifyProof({ proof: forged })).verified, false) && pass;
+    console.log('\n=== SELF-TEST:', pass ? 'ALL PASS' : 'FAILURES', '===');
+    process.exit(pass ? 0 : 1);
+}
+main();

package/dist/verify_proof.js

@@ -0,0 +1,71 @@
+import { createPublicKey, verify as edVerify } from 'node:crypto';
+import { wfCanonical, sha256hex } from './canonical.js';
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+// Reconstruct the signable EXACTLY as wfGenerateProof did. Version-aware:
+// proofs with external_cost_hash were signed over 10 fields, older ones over 8.
+// Types matter (wfCanonical stringifies 5 vs "5" differently):
+//   cost_pence, budget_pence, retrieved_count, started_at -> NUMBER
+//   completed_at -> STRING
+function buildSignable(p) {
+    const hasExt = p.external_cost_hash !== undefined && p.external_cost_hash !== null;
+    const base = {
+        task_id: p.task_id,
+        agent_id: p.agent_id,
+        input_hash: p.input_hash,
+        output_hash: p.output_hash,
+        cost_pence: Number(p.cost_pence),
+        budget_pence: Number(p.budget_pence),
+        started_at: Number(p.started_at),
+        completed_at: String(p.completed_at),
+    };
+    if (hasExt) {
+        base.external_cost_hash = String(p.external_cost_hash);
+        base.retrieved_count = Number(p.retrieved_count ?? 0);
+        return { signable: base, fields: 10 };
+    }
+    return { signable: base, fields: 8 };
+}
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`fetch ${url} -> HTTP ${res.status}`);
+    return res.json();
+}
+// Trustless verification: fetch public key (+ optionally proof), reconstruct
+// signable, verify Ed25519 locally. Server never asked "is this valid?".
+export async function verifyProof(args) {
+    let proof = args.proof;
+    if (!proof) {
+        if (!args.task_id)
+            throw new Error('Provide task_id or proof');
+        const data = await fetchJson(`${FD_API}/v1/workforce/proof/${encodeURIComponent(args.task_id)}/public`);
+        if (!data?.proof)
+            throw new Error('proof_not_found');
+        proof = data.proof;
+    }
+    const keyData = await fetchJson(`${FD_API}/v1/workforce/proof/public-key`);
+    const pub = createPublicKey(keyData.public_key_pem);
+    const { signable, fields } = buildSignable(proof);
+    const digest = sha256hex(wfCanonical(signable));
+    let verified = false;
+    if (proof.signature && (proof.algorithm === 'Ed25519' || !proof.algorithm)) {
+        try {
+            verified = edVerify(null, Buffer.from(digest, 'hex'), pub, Buffer.from(String(proof.signature), 'base64'));
+        }
+        catch {
+            verified = false;
+        }
+    }
+    return {
+        verified,
+        task_id: proof.task_id,
+        key_id: keyData.key_id,
+        algorithm: 'Ed25519',
+        fields_signed: fields,
+        trustless: true,
+        message: verified
+            ? 'Signature mathematically verified. This proof was signed by ForceDream and has not been altered.'
+            : 'Signature verification FAILED. The proof was altered or not signed by ForceDream.',
+        note: 'Verified client-side via public-key cryptography. ForceDream was not asked whether the proof is valid.',
+    };
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@forcedream/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for ForceDream \u2014 discover, invoke, and trustlessly verify AI agents with cryptographic proofs.",
+  "type": "module",
+  "bin": {
+    "fd-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "verify-test": "node dist/selftest.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@noble/ed25519": "^2.1.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "forcedream",
+    "ai-agents",
+    "cryptographic-proof",
+    "ed25519",
+    "claude"
+  ],
+  "homepage": "https://www.forcedream.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/forcedreamai/forcedream.git",
+    "directory": "packages/mcp-server"
+  },
+  "author": "ForceDream"
+}