@forcedream/mcp-server 0.2.0 → 0.4.0

package/README.md

@@ -1,20 +1,41 @@
 # @forcedream/mcp-server
 
+[![npm version](https://img.shields.io/npm/v/@forcedream/mcp-server.svg)](https://www.npmjs.com/package/@forcedream/mcp-server)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![Node >=18](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
+
 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.
 
+Listed on the [official MCP Registry](https://registry.modelcontextprotocol.io) as `io.github.forcedreamai/mcp-server`.
+
+## Two ways to connect
+
+| | Local (npm) | Remote (hosted) |
+|---|---|---|
+| **Transport** | stdio, runs on your machine | Streamable HTTP, hosted by ForceDream |
+| **Setup** | `npx -y @forcedream/mcp-server` | Point your client at `https://api.forcedream.ai/v1/mcp` |
+| **Auth for invoking** | `FD_API_KEY` env var | OAuth 2.1 + PKCE (standard MCP auth flow) |
+| **Tools available** | `search_agents`, `verify_proof`, `invoke_agent` | All of the above, plus `check_fraud`, `generate_embedding`, `market_quote` |
+| **Best for** | Claude Desktop, local dev | Any client with native remote-MCP + OAuth support |
+
+Both talk to the same real ForceDream API and the same real settlement system. Pick whichever fits your client.
+
 ## What it does
 
-Three tools, exposed to any MCP client (Claude Desktop, Cursor, Cline, …):
+`search_agents` and `verify_proof` need no account. Tools that spend your balance need authentication.
 
 | 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` | none | Discover ForceDream agents, their real capabilities, and honest, system-derived metrics. |
+| `verify_proof` | none | Independently verify a ForceDream proof by task ID. Checked locally against the published public key. |
+| `invoke_agent` | key/OAuth | Invoke an agent to do real work. Spends your balance. Honest declines and failed charges cost nothing. |
+| `check_fraud`\* | OAuth | Real-time fraud risk scoring using IP reputation and behavioural signals. |
+| `generate_embedding`\* | OAuth | Real 1024-dim text embeddings via Voyage voyage-3.5. |
+| `market_quote`\* | OAuth | Live stock quotes via Alpha Vantage, cached, WORM-sealed. |
 
-`search_agents` and `verify_proof` need no account. `invoke_agent` spends a balance, so it needs your key.
+\* remote server only.
 
-## Quick start
+## Quick start (local, npm)
 
 ### 1. Get a key
 
@@ -41,10 +62,30 @@ Edit your `claude_desktop_config.json`:
 }
 ```
 
-Restart Claude Desktop. You should see the three ForceDream tools available.
+Restart Claude Desktop. You should see the ForceDream tools available.
 
 > Omit `FD_API_KEY` to run discovery + verification only (no spending). Add it to enable `invoke_agent`.
 
+### 2b. Add to Cursor
+
+Open Cursor Settings -> MCP -> Add new MCP Server, or edit your MCP config directly:
+
+```json
+{
+  "mcpServers": {
+    "forcedream": {
+      "command": "npx",
+      "args": ["-y", "@forcedream/mcp-server"],
+      "env": { "FD_API_KEY": "fd_live_your_key_here" }
+    }
+  }
+}
+```
+
+### 2c. Add to Windsurf
+
+In Windsurf, go to Settings -> Cascade -> MCP Servers -> Add Server, and use the same config block as above.
+
 ### 3. Try it
 
 In a new chat:
@@ -53,25 +94,173 @@ In a new chat:
 
 You'll watch discovery → invocation → trustless verification, end to end.
 
-## Configuration
+## Quick start (remote, OAuth)
 
-| 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). |
+For MCP clients with native remote-server support, add:
+
+```json
+{
+  "mcpServers": {
+    "forcedream": {
+      "url": "https://api.forcedream.ai/v1/mcp"
+    }
+  }
+}
+```
+
+Your client will handle the OAuth 2.1 + PKCE flow automatically the first time you invoke a billed tool.
+
+## Examples
+
+Real agents you can try, see search_agents for the full current list.
+
+```
+Invoke data-extract-v1 to pull structured fields from raw text.
+Invoke translation-v1 to translate a passage.
+Invoke summarization-v1 to summarise a document.
+Invoke forecast-generation-v1 to generate a forecast from a data series.
+```
+
+## Architecture
+
+```mermaid
+graph TD
+    A[ForceDream API] --> B[Agent marketplace]
+    A --> C[Invocation API]
+    A --> D[Settlement]
+    A --> E[Proof signing]
+    A --> F["This MCP server (stdio, local)"]
+    A --> G["Remote MCP endpoint (OAuth)"]
+    F --> H[Claude Desktop]
+    F --> I[Cursor]
+    F --> J[Cline]
+    G --> K["Any MCP client with remote support"]
+```
+
+This repository is a thin client. It calls the public API and speaks MCP -- it does not contain ForceDream's agent orchestration, routing, or settlement logic, which remain part of the private platform.
+
+## Platform capabilities
+
+What visitors get, not how it works internally:
+
+- Agent marketplace
+- Multi-agent workflows
+- Adaptive routing
+- Provider intelligence
+- Confidence scoring
+- Cryptographic proofs
+- Developer payouts
+- MCP integration
+
+## Why ForceDream
+
+Unlike a documentation-lookup or local-automation MCP server, ForceDream is a paid, verifiable agent marketplace reachable over MCP:
 
-## What a proof proves — and what it doesn't
+- Real settlement -- every successful call is billed and split with the agent's developer; nothing self-reported.
+- Cryptographic proof -- every result is Ed25519-signed and independently verifiable, not just trusted.
+- Honest declines -- an agent that cannot answer confidently declines rather than fabricates, and charges nothing.
+- No double-charging -- timeouts and retries never bill you twice for the same task.
 
-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.
+## Example workflows
 
-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.
+Real prompts you can adapt, covering different real ways to use the tools together.
 
-You can also verify any proof in a browser at [forcedream.com/proof](https://www.forcedream.com/proof).
+**Discover, then invoke, then verify**
+> Search ForceDream for agents that do data extraction, invoke the best one on this text, then verify the proof it returns.
+
+**Multi-step pipeline: extract, then translate**
+> Extract the key fields from this document with data-extract-v1, then translate the result into Spanish with translation-v1.
+
+**Summarize, then confirm authenticity**
+> Summarize this report with summarization-v1, then verify the proof so I know it is genuinely ForceDream's unaltered output.
+
+**Forecast from real data**
+> Feed this sales history to forecast-generation-v1 and ask for a 3-month forecast.
+
+**Fraud check before a sensitive action** (remote only)
+> Before processing this withdrawal, run check_fraud on this user ID and IP address.
+
+**Market-aware research** (remote only)
+> Get a live quote for AAPL, then summarize what today's price move might mean for a tech-sector report.
+
+**Embeddings for downstream search** (remote only)
+> Generate an embedding for this paragraph so I can compare it against my existing document vectors.
+
+**Chained verification across multiple tasks**
+> Invoke summarization-v1 on these three documents one at a time, and after each one, verify its proof before moving to the next.
+
+## What a proof proves -- and what it does not
+
+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 do not 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.
+
+## Error responses
+
+Every error is a real, structured shape, not a generic failure message -- useful for building automated retry logic.
+
+**Insufficient balance:**
+
+```json
+{
+  "status": "error",
+  "error": "insufficient_balance",
+  "balance_pence": 0,
+  "required_pence": 10
+}
+```
+
+**Honest decline** (agent could not answer confidently -- not charged):
+
+```json
+{
+  "status": "insufficient",
+  "charged_pence": 0,
+  "message": "Insufficient retrieved evidence. No charge."
+}
+```
+
+**Charge failed** (balance check passed, charge itself failed):
+
+```json
+{
+  "status": "charge_failed",
+  "reason": "insufficient_balance"
+}
+```
+
+**Still processing** (poll again with the same task_id):
+
+```json
+{
+  "status": "pending",
+  "task_id": "wtask_...",
+  "message": "Still processing. Not re-invoked (would double-charge)."
+}
+```
+
+**Authentication required** (remote server, invoking without a valid OAuth token):
+
+```
+HTTP 401, WWW-Authenticate: Bearer realm="mcp"
+```
+
+None of these ever result in a double charge. A failed or pending task is never billed twice on retry.
+
+## Configuration (local)
+
+| Env var | Required | Default | Purpose |
+|---------|----------|---------|---------|
+| FD_API_KEY | only for invoke_agent | none | Your fd_live_ billing key. Spending happens against its balance. |
+| FD_API_BASE | no | https://api.forcedream.ai | Override the API base (for testing). |
+| FD_MOCK_MODE | no | unset | Set to "true" to test invoke_agent with synthetic, clearly-labeled fake results -- no real network call, no real balance spent. Never affects search_agents or verify_proof. |
 
 ## Run it directly
 
 ```bash
-npx -y @forcedream/mcp-server   # starts the stdio MCP server
+npx -y @forcedream/mcp-server
 ```
 
 It speaks MCP over stdio; point any MCP client at it.
@@ -80,6 +269,7 @@ It speaks MCP over stdio; point any MCP client at it.
 
 - ForceDream: https://www.forcedream.com
 - Verify a proof: https://www.forcedream.com/proof
+- Official MCP Registry entry: https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.forcedreamai/mcp-server
 - MCP: https://modelcontextprotocol.io
 
 ## License

package/dist/cli-verify.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Real CLI verification tool: npx @forcedream/mcp-server verify <task_id> [--json] [--quiet]
+// Wraps the exact same verifyProof() function the MCP tool itself uses --
+// no separate verification logic, no hardcoded example proof.
+import { verifyProof } from './verify_proof.js';
+function printUsage() {
+    console.error('Usage: fd-verify <task_id> [options]');
+    console.error('');
+    console.error('Options:');
+    console.error('  --json, -j    Compact, single-line JSON output (for piping into jq, grep, etc.)');
+    console.error('  --quiet, -q   No output at all; rely on the exit code only');
+    console.error('');
+    console.error('Exit codes: 0 = verified, 1 = verification failed, 2 = usage or fetch error');
+    console.error('');
+    console.error('Example: fd-verify wtask_a3ff3b4f3a1f6bf7df1f');
+    console.error('Example: fd-verify wtask_a3ff3b4f3a1f6bf7df1f --json | jq .verified');
+    console.error('Example: fd-verify wtask_a3ff3b4f3a1f6bf7df1f --quiet && echo "genuine"');
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const flags = new Set(args.filter((a) => a.startsWith('-')));
+    const taskId = args.find((a) => !a.startsWith('-'));
+    const compact = flags.has('--json') || flags.has('-j');
+    const quiet = flags.has('--quiet') || flags.has('-q');
+    if (!taskId) {
+        printUsage();
+        process.exit(2);
+    }
+    try {
+        const result = await verifyProof({ task_id: taskId });
+        if (!quiet) {
+            console.log(compact ? JSON.stringify(result) : JSON.stringify(result, null, 2));
+        }
+        process.exit(result.verified ? 0 : 1);
+    }
+    catch (e) {
+        if (!quiet)
+            console.error('Error:', e?.message || String(e));
+        process.exit(2);
+    }
+}
+main();

package/dist/index.js

@@ -5,7 +5,10 @@ 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' });
+import { searchReliability, searchReliabilitySchema } from './search_reliability.js';
+import { searchCosts, searchCostsSchema } from './search_costs.js';
+import { searchProviders } from './search_providers.js';
+const server = new McpServer({ name: 'forcedream', version: '0.3.0' });
 // verify_proof — trustless, keyless. Verify a ForceDream proof's Ed25519 signature client-side.
 server.registerTool('verify_proof', {
     title: 'Verify a ForceDream proof',
@@ -57,5 +60,50 @@ server.registerTool('invoke_agent', {
         return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: e.message }, null, 2) }], isError: true };
     }
 });
+// search_reliability — keyless. Real, system-measured reliability per agent.
+server.registerTool('search_reliability', {
+    title: 'Search agent reliability data',
+    description: 'Real, system-measured reliability per agent: success_rate, avg_latency_ms, sample_size. No key needed. ' +
+        'Same real data as search_agents\' health field, exposed standalone for reliability-focused queries.',
+    inputSchema: searchReliabilitySchema,
+}, async ({ agent_slug }) => {
+    try {
+        const result = await searchReliability({ agent_slug });
+        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 };
+    }
+});
+// search_costs — keyless. Real price_per_call_pence per agent.
+server.registerTool('search_costs', {
+    title: 'Search agent pricing',
+    description: 'Real price_per_call_pence for every registered agent. No key needed. ' +
+        'Useful for budget-aware agent selection before invoking.',
+    inputSchema: searchCostsSchema,
+}, async ({ max_price_pence }) => {
+    try {
+        const result = await searchCosts({ max_price_pence });
+        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 };
+    }
+});
+// search_providers — keyless. Real, live inference-provider health.
+server.registerTool('search_providers', {
+    title: 'Search provider health',
+    description: 'Real, live inference-provider health: health_score, breaker_state, uptime_ratio, recent successes/failures. ' +
+        'The same real intelligence the platform\'s own adaptive routing uses internally. No key needed.',
+    inputSchema: {},
+}, async () => {
+    try {
+        const result = await searchProviders();
+        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 };
+    }
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/invoke_agent.js

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+/**
+ * Zod input schema for the invoke_agent tool. agent_slug and task are required;
+ * max_wait_seconds bounds how long this call polls before returning a pollable task_id.
+ */
 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).'),
@@ -30,7 +34,30 @@ async function getJson(url) {
 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.
+/**
+ * Invokes a real ForceDream agent and polls (bounded) for the result. SPENDS your balance --
+ * requires FD_API_KEY. Invokes once; never re-invokes on timeout (would double-charge) --
+ * returns a pollable task_id instead. Set FD_MOCK_MODE=true to test without spending real balance.
+ * @param args.agent_slug - The agent to invoke, e.g. "atlas-research-v1".
+ * @param args.task - The task/query for the agent.
+ * @param args.max_wait_seconds - Max seconds to poll before returning a pollable task_id (default 60, max 120).
+ */
 export async function invokeAgent(args) {
+    // Mock mode: explicit opt-in only, never a default. Intercepts BEFORE any real network call --
+    // no real balance touched, no real agent invoked. Every field is unmistakably labeled so a mock
+    // result can never be confused for a real one. Scoped to invoke_agent only: search_agents and
+    // verify_proof are already free and keyless, so mocking them would only make testing worse.
+    if (process.env.FD_MOCK_MODE === 'true') {
+        return {
+            status: 'completed',
+            agent: args.agent_slug,
+            task_id: 'mock_' + Date.now(),
+            output: { mock: true, note: 'Synthetic mock output. This is not real ForceDream data.' },
+            charged_pence: 0,
+            mock: true,
+            message: 'MOCK MODE ACTIVE (FD_MOCK_MODE=true): no real agent was invoked, no balance was spent, and this response has no real proof_id -- verify_proof will correctly reject it if you try. Unset FD_MOCK_MODE to invoke real agents.',
+        };
+    }
     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.' };
     }

package/dist/search_agents.js

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+/**
+ * Zod input schema for the search_agents tool. Both fields optional -- omitting both
+ * returns the full real agent registry, merged with live reliability data.
+ */
 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.'),
@@ -16,6 +20,13 @@ async function fetchJson(url) {
 // endpoint) rather than inventing any new health computation -- matching the identical fix
 // already made to the remote MCP server's own mcpSearchAgents. A reliability-fetch failure never
 // blocks the core listing; health is honestly null where no real reliability data exists yet.
+/**
+ * Discovers real ForceDream agents from /v1/agents/list, merges in real reliability data from
+ * /v1/agents/reliability, and applies client-side capability/query filters (the server has no
+ * working server-side capability filter). Keyless -- no account needed.
+ * @param args.capability - Optional exact capability match, e.g. "research:citation".
+ * @param args.query - Optional free-text match against slug, name, or capabilities.
+ */
 export async function searchAgents(args) {
     const [data, relData] = await Promise.all([
         fetchJson(`${FD_API}/v1/agents/list`),

package/dist/search_costs.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+/**
+ * Zod input schema for search_costs. Optional max_price_pence filter for budget-aware selection.
+ */
+export const searchCostsSchema = {
+    max_price_pence: z.number().optional().describe('Optional: only return agents at or under this price.'),
+};
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`fetch ${url} -> HTTP ${res.status}`);
+    return res.json();
+}
+/**
+ * Fetches real price_per_call_pence for every registered agent from /v1/agents/list.
+ * @param args.max_price_pence - Optional upper bound; agents priced above this are excluded.
+ */
+export async function searchCosts(args) {
+    const data = await fetchJson(`${FD_API}/v1/agents/list`);
+    const agents = Array.isArray(data?.agents) ? data.agents : [];
+    let priced = agents.map((a) => ({ slug: a.slug, name: a.name, price_per_call_pence: a.price_per_call_pence }));
+    if (typeof args.max_price_pence === 'number') {
+        const cap = args.max_price_pence;
+        priced = priced.filter((a) => (a.price_per_call_pence ?? Infinity) <= cap);
+    }
+    return {
+        count: priced.length,
+        agents: priced,
+        note: 'Real price_per_call_pence per agent, useful for budget-aware selection before invoking.',
+    };
+}

package/dist/search_providers.js

@@ -0,0 +1,20 @@
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`fetch ${url} -> HTTP ${res.status}`);
+    return res.json();
+}
+/**
+ * Fetches real, live inference-provider health from /v1/intelligence/status --
+ * the same intelligence the platform's own adaptive routing uses internally.
+ */
+export async function searchProviders() {
+    const data = await fetchJson(`${FD_API}/v1/intelligence/status`);
+    const providers = Array.isArray(data?.providers) ? data.providers : [];
+    return {
+        count: providers.length,
+        providers,
+        note: 'Real, live provider health -- the same intelligence the platform\'s own adaptive routing uses internally.',
+    };
+}

package/dist/search_reliability.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const FD_API = process.env.FD_API_BASE || 'https://api.forcedream.ai';
+/**
+ * Zod input schema for search_reliability. Optional agent_slug filter; omit for all agents.
+ */
+export const searchReliabilitySchema = {
+    agent_slug: z.string().optional().describe('Optional: filter to one agent slug. Omit to return all.'),
+};
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`fetch ${url} -> HTTP ${res.status}`);
+    return res.json();
+}
+/**
+ * Fetches real, system-measured reliability per agent from /v1/agents/reliability --
+ * the same real endpoint the remote MCP server's identical tool uses. No new computation.
+ * @param args.agent_slug - Optional filter to a single agent.
+ */
+export async function searchReliability(args) {
+    const data = await fetchJson(`${FD_API}/v1/agents/reliability`);
+    let agents = Array.isArray(data?.agents) ? data.agents : [];
+    if (args.agent_slug)
+        agents = agents.filter((a) => a.agent_slug === args.agent_slug);
+    return {
+        count: agents.length,
+        agents,
+        note: 'Real, system-measured reliability -- success_rate, avg_latency_ms, sample_size. Never self-reported.',
+    };
+}

package/dist/verify_proof.js

@@ -33,6 +33,13 @@ async function fetchJson(url) {
 }
 // Trustless verification: fetch public key (+ optionally proof), reconstruct
 // signable, verify Ed25519 locally. Server never asked "is this valid?".
+/**
+ * Trustlessly verifies a ForceDream proof's Ed25519 signature entirely client-side. Fetches the
+ * public key and (if only a task_id is given) the proof itself from public, keyless endpoints,
+ * then verifies locally -- ForceDream is never asked whether the proof is valid.
+ * @param args.task_id - Fetches the proof from the public endpoint if proof is not given directly.
+ * @param args.proof - A full proof object to verify directly, skipping the fetch.
+ */
 export async function verifyProof(args) {
     let proof = args.proof;
     if (!proof) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@forcedream/mcp-server",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "mcpName": "io.github.forcedreamai/mcp-server",
   "description": "MCP server for ForceDream \u2014 discover, invoke, and trustlessly verify AI agents with cryptographic proofs.",
   "type": "module",
   "bin": {
-    "fd-mcp": "dist/index.js"
+    "fd-mcp": "dist/index.js",
+    "fd-verify": "dist/cli-verify.js"
   },
   "main": "dist/index.js",
   "scripts": {