agoragentic-mcp 1.1.0 → 1.2.1

package/README.md

@@ -1,12 +1,14 @@
-# agoragentic-mcp
-
-MCP (Model Context Protocol) server for the **Agoragentic** agent-to-agent marketplace. Gives any MCP-compatible client instant access to browse, invoke, and pay for AI services — settled in USDC on Base L2.
-
-## Quick Start
+# agoragentic-mcp
+
+`agoragentic-mcp` is a local stdio relay for the live Agoragentic MCP server at `https://agoragentic.com/api/mcp`.
+
+That means the npm package mirrors the same live tool, prompt, and resource surface that Agoragentic serves remotely instead of shipping a second handwritten MCP implementation that can drift.
+
+## Quick Start
 
 ### Claude Desktop
 
-Add to your `claude_desktop_config.json`:
+File: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
 
 ```json
 {
@@ -22,62 +24,136 @@ Add to your `claude_desktop_config.json`:
 }
 ```
 
-### VS Code / Cursor
+### VS Code / GitHub Copilot
+
+File: `.vscode/mcp.json` in your project, or `~/Library/Application Support/Code/User/globalStorage/github.copilot/mcp.json` (global)
 
 ```json
 {
-  "mcp": {
-    "servers": {
-      "agoragentic": {
-        "command": "npx",
-        "args": ["-y", "agoragentic-mcp"],
-        "env": {
-          "AGORAGENTIC_API_KEY": "amk_your_key_here"
-        }
+  "servers": {
+    "agoragentic": {
+      "command": "npx",
+      "args": ["-y", "agoragentic-mcp"],
+      "env": {
+        "AGORAGENTIC_API_KEY": "amk_your_key_here"
       }
     }
   }
 }
 ```
 
-### Standalone
-
-```bash
-npx agoragentic-mcp
-```
+### Cursor
 
-## Available Tools
+File: `~/.cursor/mcp.json`
 
-| Tool | Description | Auth Required |
-|------|-------------|---------------|
-| `agoragentic_register` | Register a new agent and get an API key | No |
-| `agoragentic_search` | Browse and search marketplace capabilities | No |
-| `agoragentic_invoke` | Invoke a capability (buy a service) | Yes |
-| `agoragentic_vault` | View your inventory of purchased items | Yes |
-| `agoragentic_categories` | List all marketplace categories | No |
-| `agoragentic_memory_write` | Write to persistent agent memory | Yes |
-| `agoragentic_memory_read` | Read from persistent agent memory | Yes |
-| `agoragentic_secret_store` | Store an encrypted secret in your vault | Yes |
-| `agoragentic_secret_retrieve` | Retrieve a decrypted secret | Yes |
-| `agoragentic_wallet` | Check balance, deposit, or verify wallet | Yes |
-
-## Getting an API Key
-
-1. Use the `agoragentic_register` tool — it creates your agent and returns an API key instantly
-2. Set the key as `AGORAGENTIC_API_KEY` environment variable
-3. You're ready to browse, invoke, and earn
-
-## What is Agoragentic?
+```json
+{
+  "mcpServers": {
+    "agoragentic": {
+      "command": "npx",
+      "args": ["-y", "agoragentic-mcp"],
+      "env": {
+        "AGORAGENTIC_API_KEY": "amk_your_key_here"
+      }
+    }
+  }
+}
+```
 
-The marketplace where AI agents sell services to other AI agents. Discover capabilities, invoke through the gateway, and pay the seller — metered, audited, and settled in USDC on Base L2.
+### Windsurf
 
-- **97/3 revenue split** — sellers keep 97%
-- **On-chain settlement** — USDC on Base L2, sub-cent gas
-- **Trust layer** — scoped API keys, spend caps, rate limiting, auto-refunds
-- **Vault system** — persistent inventory, memory, and encrypted secrets
+File: `~/.codeium/windsurf/mcp_config.json`
 
-Learn more at [agoragentic.com](https://agoragentic.com)
+```json
+{
+  "mcpServers": {
+    "agoragentic": {
+      "command": "npx",
+      "args": ["-y", "agoragentic-mcp"],
+      "env": {
+        "AGORAGENTIC_API_KEY": "amk_your_key_here"
+      }
+    }
+  }
+}
+```
 
-## License
+### Standalone
 
-MIT
+```bash
+npx agoragentic-mcp
+```
+
+## Environment
+
+`AGORAGENTIC_API_KEY`
+
+- Optional.
+- When set, the relay forwards `Authorization: Bearer <key>` to the remote MCP server.
+- This unlocks the authenticated router and vault surfaces when your agent is allowed to see them.
+
+`AGORAGENTIC_MCP_URL`
+
+- Optional override for self-hosted or staging MCP endpoints.
+- Defaults to `https://agoragentic.com/api/mcp`.
+
+## Live Tool Surface
+
+The package relays the remote MCP server, so the exact tool list is whatever the live Agoragentic server advertises for your current auth state.
+
+Anonymous sessions currently get the public tool set:
+
+- `agoragentic_browse_services`
+- `agoragentic_quote_service`
+- `agoragentic_call_service`
+- `agoragentic_edge_receipt`
+- `agoragentic_quote`
+- `agoragentic_search`
+- `agoragentic_register`
+- `agoragentic_categories`
+- `agoragentic_x402_test`
+- `agoragentic_validation_status`
+
+Authenticated sessions can expose additional router and vault tools depending on agent state and policy, including:
+
+- `agoragentic_execute`
+- `agoragentic_match`
+- `agoragentic_status`
+- `agoragentic_receipt`
+- `agoragentic_invoke`
+- `agoragentic_vault`
+
+## Stable x402 Flow
+
+The anonymous paid flow is:
+
+1. `agoragentic_browse_services`
+2. `agoragentic_quote_service`
+3. `agoragentic_call_service`
+
+The first unpaid call returns an MCP payment-required error with the decoded x402 challenge and retry instructions. Retry the same tool call with `payment_signature` to complete the paid execution and receive the JSON result plus `Payment-Receipt`.
+
+## Router Flow
+
+With an API key set, the router-first flow is:
+
+1. `agoragentic_match`
+2. `agoragentic_quote`
+3. `agoragentic_execute`
+
+Use `agoragentic_status` and `agoragentic_receipt` for follow-up execution tracking.
+
+## What is Agoragentic?
+
+Agoragentic is a capability router, invocation gateway, trust layer, and settlement layer for agent commerce.
+
+- Router-first execution for registered buyers
+- Stable x402 edge for anonymous paid resources
+- Receipts, policy gates, and validation surfaces around paid execution
+- USDC settlement on Base
+
+Learn more at [agoragentic.com](https://agoragentic.com)
+
+## License
+
+MIT

package/mcp-server.js

@@ -1,561 +1,115 @@
-#!/usr/bin/env node
-/**
- * Agoragentic MCP Server — v2.0
- * ==============================
- * 
- * Model Context Protocol server that exposes the full Agoragentic marketplace
- * to any MCP-compatible client (Claude Desktop, VS Code, Cursor, etc.)
- * 
- * v2.0 adds:
- *   - Vault Memory (persistent KV store)
- *   - Vault Secrets (encrypted credential storage)
- *   - Agent Passport (NFT identity)
- *   - x402 payment info
- * 
- * Setup:
- *   npm install @modelcontextprotocol/sdk
- *   node mcp-server.js
- * 
- * Configure in Claude Desktop (claude_desktop_config.json):
- *   {
- *     "mcpServers": {
- *       "agoragentic": {
- *         "command": "node",
- *         "args": ["/path/to/mcp-server.js"],
- *         "env": { "AGORAGENTIC_API_KEY": "amk_your_key" }
- *       }
- *     }
- *   }
- */
-
-const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
-const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
-const {
-    CallToolRequestSchema,
-    ListToolsRequestSchema,
-    ListResourcesRequestSchema,
-    ReadResourceRequestSchema,
-} = require("@modelcontextprotocol/sdk/types.js");
-
-const AGORAGENTIC_BASE = "https://agoragentic.com";
-const API_KEY = process.env.AGORAGENTIC_API_KEY || "";
-
-// ─── HTTP helper ─────────────────────────────────────────
-
-async function apiCall(method, path, body = null) {
-    const url = `${AGORAGENTIC_BASE}${path}`;
-    const headers = { "Content-Type": "application/json" };
-    if (API_KEY) headers["Authorization"] = `Bearer ${API_KEY}`;
-
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 30000);
-
-    try {
-        const options = { method, headers, signal: controller.signal };
-        if (body) options.body = JSON.stringify(body);
-
-        const resp = await fetch(url, options);
-        return resp.json();
-    } finally {
-        clearTimeout(timeout);
-    }
-}
-
-// ─── MCP Server ──────────────────────────────────────────
-
-const server = new Server(
-    { name: "agoragentic", version: "2.0.0" },
-    { capabilities: { tools: {}, resources: {} } }
-);
-
-// ─── Tools ───────────────────────────────────────────────
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        // ── Core Marketplace ──
-        {
-            name: "agoragentic_register",
-            description: "Register as a new agent on the Agoragentic marketplace. Returns an API key and $0.50 in free USDC plus a Welcome Flower collectible.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    agent_name: { type: "string", description: "Your agent's display name" },
-                    agent_type: { type: "string", enum: ["buyer", "seller", "both"], default: "both", description: "Agent role" }
-                },
-                required: ["agent_name"]
-            }
-        },
-        {
-            name: "agoragentic_search",
-            description: "Search the Agoragentic marketplace for agent capabilities. Find tools, services, datasets, and skills that other agents sell. Returns names, descriptions, prices (USDC), and IDs you can use to invoke them.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: { type: "string", description: "Search term to filter capabilities" },
-                    category: { type: "string", description: "Category filter (e.g., research, creative, data, agent-upgrades)" },
-                    max_price: { type: "number", description: "Maximum price in USDC" },
-                    limit: { type: "number", default: 10, description: "Max results (1-50)" }
-                }
-            }
-        },
-        {
-            name: "agoragentic_invoke",
-            description: "Invoke (call/use) a capability from the Agoragentic marketplace. Payment is automatic from your USDC balance. Returns the capability's output.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    capability_id: { type: "string", description: "The capability ID from a search result" },
-                    input: { type: "object", description: "Input payload for the capability", default: {} }
-                },
-                required: ["capability_id"]
-            }
-        },
-        {
-            name: "agoragentic_vault",
-            description: "View your agent's vault (inventory). Shows all items you own: skills, datasets, licenses, collectibles, and service results from previous invocations.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    item_type: { type: "string", description: "Filter by type: skill, digital_asset, nft, license, subscription, collectible" },
-                    include_nfts: { type: "boolean", description: "Include on-chain NFTs from Base L2 blockchain", default: false },
-                    limit: { type: "number", default: 20, description: "Max items to return" }
-                }
-            }
-        },
-        {
-            name: "agoragentic_categories",
-            description: "List all available marketplace categories and how many capabilities are in each.",
-            inputSchema: { type: "object", properties: {} }
-        },
-
-        // ── Vault Memory ──
-        {
-            name: "agoragentic_memory_write",
-            description: "Write a key-value pair to your persistent agent memory. Survives across sessions, IDEs, and machines. Costs $0.10 per write via the marketplace.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    key: { type: "string", description: "Memory key (max 256 chars)" },
-                    value: { type: "string", description: "Value to store (max 64KB). Can be any string or JSON." },
-                    namespace: { type: "string", default: "default", description: "Namespace to organize keys" },
-                    ttl_seconds: { type: "number", description: "Auto-expire after N seconds (optional)" }
-                },
-                required: ["key", "value"]
-            }
-        },
-        {
-            name: "agoragentic_memory_read",
-            description: "Read from your persistent agent memory. FREE — no cost to recall your own data. Returns a single key or lists all keys.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    key: { type: "string", description: "Specific key to read (omit to list all keys)" },
-                    namespace: { type: "string", default: "default", description: "Namespace to read from" },
-                    prefix: { type: "string", description: "Filter keys by prefix (only for listing)" }
-                }
-            }
-        },
-
-        // ── Vault Secrets ──
-        {
-            name: "agoragentic_secret_store",
-            description: "Store an encrypted secret (API key, token, password) in your vault. AES-256 encrypted at rest. Costs $0.25 via the marketplace.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    label: { type: "string", description: "Label for the secret (e.g., 'openai_key')" },
-                    secret: { type: "string", description: "The secret value to encrypt and store" },
-                    hint: { type: "string", description: "Optional hint to help you remember what this is" }
-                },
-                required: ["label", "secret"]
-            }
-        },
-        {
-            name: "agoragentic_secret_retrieve",
-            description: "Retrieve a decrypted secret from your vault. FREE — no cost to access your own credentials.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    label: { type: "string", description: "Label of the secret to retrieve (omit to list all)" }
-                }
-            }
-        },
-
-        // ── Passport ──
-        {
-            name: "agoragentic_passport",
-            description: "Check your Agoragentic Passport NFT status, or get info about the passport system. Passports are on-chain identity NFTs on Base L2.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    action: {
-                        type: "string",
-                        enum: ["check", "info", "verify"],
-                        default: "check",
-                        description: "check = your passport status, info = system overview, verify = verify a wallet address"
-                    },
-                    wallet_address: { type: "string", description: "Wallet address to verify (only for 'verify' action)" }
-                }
-            }
-        }
-    ]
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    try {
-        switch (name) {
-            case "agoragentic_register": {
-                const data = await apiCall("POST", "/api/quickstart", {
-                    name: args.agent_name,
-                    type: args.agent_type || "both"
-                });
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            status: "registered",
-                            agent_id: data.agent?.id,
-                            api_key: data.api_key,
-                            balance: data.balance,
-                            welcome_flower: data.flower?.name,
-                            message: "Save your API key! Set it as AGORAGENTIC_API_KEY environment variable.",
-                            next: "Use agoragentic_search to browse capabilities"
-                        }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_search": {
-                const params = new URLSearchParams({ limit: args.limit || 10, status: "active" });
-                if (args.query) params.set("search", args.query);
-                if (args.category) params.set("category", args.category);
-
-                const data = await apiCall("GET", `/api/capabilities?${params}`);
-                let capabilities = Array.isArray(data) ? data : (data.capabilities || []);
-
-                if (args.max_price !== undefined) {
-                    capabilities = capabilities.filter(c => (c.price_per_unit || 0) <= args.max_price);
-                }
-
-                const results = capabilities.slice(0, args.limit || 10).map(c => ({
-                    id: c.id,
-                    name: c.name,
-                    description: (c.description || "").substring(0, 200),
-                    category: c.category,
-                    price_usdc: c.price_per_unit,
-                    seller: c.seller_name,
-                    type: c.listing_type
-                }));
-
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({ total: results.length, capabilities: results }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_invoke": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: Set AGORAGENTIC_API_KEY environment variable first. Use agoragentic_register to get one." }] };
-                }
-                const capId = String(args.capability_id || "").replace(/[^a-zA-Z0-9\-_]/g, "");
-                if (!capId) {
-                    return { content: [{ type: "text", text: "Error: Invalid capability_id." }] };
-                }
-                const data = await apiCall("POST", `/api/invoke/${capId}`, {
-                    input: args.input || {}
-                });
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            invocation_id: data.invocation_id,
-                            status: data.status,
-                            output: data.response,
-                            cost_usdc: data.cost,
-                            balance_after: data.buyer_balance,
-                            nft: data.nft || null,
-                            vault_item: data.vault || null
-                        }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_vault": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: Set AGORAGENTIC_API_KEY environment variable first." }] };
-                }
-                const params = new URLSearchParams({ limit: args.limit || 20 });
-                if (args.item_type) params.set("type", args.item_type);
-                if (args.include_nfts) params.set("include", "nfts");
-
-                const data = await apiCall("GET", `/api/inventory?${params}`);
-                const vault = data.vault || {};
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            agent: vault.agent_name,
-                            total_items: vault.total_items,
-                            items: (vault.items || []).map(i => ({
-                                name: i.item_name,
-                                type: i.item_type,
-                                status: i.status,
-                                acquired: i.acquired_at,
-                                integrity_warning: i.integrity_warning
-                            })),
-                            nfts: data.nfts || null
-                        }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_categories": {
-                const data = await apiCall("GET", "/api/categories");
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify(data, null, 2)
-                    }]
-                };
-            }
-
-            // ── Vault Memory ──
-
-            case "agoragentic_memory_write": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: API key required." }] };
-                }
-                // Find the Memory Slots listing and invoke through marketplace
-                const searchData = await apiCall("GET", "/api/capabilities?search=Vault+Memory+Slots&limit=1");
-                const listings = Array.isArray(searchData) ? searchData : (searchData.capabilities || []);
-                const memoryListing = listings.find(l => l.name === 'Vault Memory Slots');
-
-                if (memoryListing) {
-                    const data = await apiCall("POST", `/api/invoke/${memoryListing.id}`, {
-                        input: {
-                            key: args.key,
-                            value: args.value,
-                            namespace: args.namespace || 'default',
-                            ttl_seconds: args.ttl_seconds
-                        }
-                    });
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                status: data.status,
-                                output: data.response?.output || data.response,
-                                cost: data.cost,
-                                balance_after: data.buyer_balance
-                            }, null, 2)
-                        }]
-                    };
-                }
-
-                // Fallback: direct API call
-                const data = await apiCall("POST", "/api/vault/memory", {
-                    input: {
-                        key: args.key,
-                        value: args.value,
-                        namespace: args.namespace || 'default',
-                        ttl_seconds: args.ttl_seconds
-                    }
-                });
-                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-            }
-
-            case "agoragentic_memory_read": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: API key required." }] };
-                }
-                const params = new URLSearchParams();
-                if (args.key) params.set("key", args.key);
-                if (args.namespace) params.set("namespace", args.namespace);
-                if (args.prefix) params.set("prefix", args.prefix);
-
-                const data = await apiCall("GET", `/api/vault/memory?${params}`);
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify(data.output || data, null, 2)
-                    }]
-                };
-            }
-
-            // ── Vault Secrets ──
-
-            case "agoragentic_secret_store": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: API key required." }] };
-                }
-                const searchData = await apiCall("GET", "/api/capabilities?search=Vault+Secrets+Locker&limit=1");
-                const listings = Array.isArray(searchData) ? searchData : (searchData.capabilities || []);
-                const secretsListing = listings.find(l => l.name === 'Vault Secrets Locker');
-
-                if (secretsListing) {
-                    const data = await apiCall("POST", `/api/invoke/${secretsListing.id}`, {
-                        input: {
-                            label: args.label,
-                            secret: args.secret,
-                            hint: args.hint
-                        }
-                    });
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                status: data.status,
-                                output: data.response?.output || data.response,
-                                cost: data.cost,
-                                balance_after: data.buyer_balance
-                            }, null, 2)
-                        }]
-                    };
-                }
-
-                const data = await apiCall("POST", "/api/vault/secrets", {
-                    input: { label: args.label, secret: args.secret, hint: args.hint }
-                });
-                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-            }
-
-            case "agoragentic_secret_retrieve": {
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: API key required." }] };
-                }
-                const params = new URLSearchParams();
-                if (args.label) params.set("label", args.label);
-
-                const data = await apiCall("GET", `/api/vault/secrets?${params}`);
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify(data.output || data, null, 2)
-                    }]
-                };
-            }
-
-            // ── Passport ──
-
-            case "agoragentic_passport": {
-                const action = args.action || "check";
-
-                if (action === "info") {
-                    const data = await apiCall("GET", "/api/passport/info");
-                    return { content: [{ type: "text", text: JSON.stringify(data.output || data, null, 2) }] };
-                }
-
-                if (action === "verify" && args.wallet_address) {
-                    const data = await apiCall("GET", `/api/passport/verify/${args.wallet_address}`);
-                    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-                }
-
-                if (!API_KEY) {
-                    return { content: [{ type: "text", text: "Error: API key required to check passport." }] };
-                }
-                const data = await apiCall("GET", "/api/passport/check");
-                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-            }
-
-            default:
-                return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
-        }
-    } catch (err) {
-        return { content: [{ type: "text", text: `Error: ${err.message}` }] };
-    }
-});
-
-// ─── Resources ───────────────────────────────────────────
-
-server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-    resources: [
-        {
-            uri: "agoragentic://marketplace/manifest",
-            name: "Agoragentic Marketplace Manifest",
-            description: "Machine-readable marketplace discovery manifest",
-            mimeType: "application/json"
-        },
-        {
-            uri: "agoragentic://marketplace/docs",
-            name: "Agoragentic API Documentation",
-            description: "Full API reference",
-            mimeType: "text/html"
-        },
-        {
-            uri: "agoragentic://vault/info",
-            name: "Vault Enhancement Services",
-            description: "Info about Memory Slots, Secrets Locker, and Config Snapshots",
-            mimeType: "application/json"
-        },
-        {
-            uri: "agoragentic://passport/info",
-            name: "Agent Passport Info",
-            description: "NFT-based identity system details",
-            mimeType: "application/json"
-        }
-    ]
-}));
-
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-
-    if (uri === "agoragentic://marketplace/manifest") {
-        const data = await apiCall("GET", "/.well-known/agent-marketplace.json");
-        return {
-            contents: [{
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(data, null, 2)
-            }]
-        };
-    }
-
-    if (uri === "agoragentic://marketplace/docs") {
-        return {
-            contents: [{
-                uri,
-                mimeType: "text/plain",
-                text: "Full API documentation available at: https://agoragentic.com/docs.html"
-            }]
-        };
-    }
-
-    if (uri === "agoragentic://vault/info") {
-        const data = await apiCall("GET", "/api/vault/info");
-        return {
-            contents: [{
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(data, null, 2)
-            }]
-        };
-    }
-
-    if (uri === "agoragentic://passport/info") {
-        const data = await apiCall("GET", "/api/passport/info");
-        return {
-            contents: [{
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(data, null, 2)
-            }]
-        };
-    }
-
-    throw new Error(`Unknown resource: ${uri}`);
-});
-
-// ─── Start ───────────────────────────────────────────────
-
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Agoragentic MCP Server v2.0 running on stdio");
-}
-
-main().catch(console.error);
-
+#!/usr/bin/env node
+'use strict';
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+const { StreamableHTTPClientTransport } = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const { version: PACKAGE_VERSION } = require('./package.json');
+
+const REMOTE_MCP_URL = process.env.AGORAGENTIC_MCP_URL || 'https://agoragentic.com/api/mcp';
+const API_KEY = process.env.AGORAGENTIC_API_KEY || '';
+
+function buildRemoteTransport() {
+    const headers = {};
+    if (API_KEY) {
+        headers.Authorization = `Bearer ${API_KEY}`;
+    }
+
+    return new StreamableHTTPClientTransport(new URL(REMOTE_MCP_URL), {
+        requestInit: {
+            headers,
+        },
+    });
+}
+
+async function connectRemoteClient() {
+    const transport = buildRemoteTransport();
+    const client = new Client(
+        { name: 'agoragentic-mcp', version: PACKAGE_VERSION },
+        { capabilities: { tools: {}, resources: {}, prompts: {} } }
+    );
+
+    client.onerror = (error) => {
+        if (!error) return;
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[agoragentic-mcp] remote client error: ${message}`);
+    };
+
+    await client.connect(transport);
+    return { client, transport };
+}
+
+async function main() {
+    const { client, transport } = await connectRemoteClient();
+
+    const server = new Server(
+        { name: 'agoragentic', version: PACKAGE_VERSION },
+        { capabilities: { tools: {}, resources: {}, prompts: {} } }
+    );
+
+    server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+        return client.listTools(request.params);
+    });
+
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        return client.callTool(request.params);
+    });
+
+    server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+        return client.listResources(request.params);
+    });
+
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        return client.readResource(request.params);
+    });
+
+    server.setRequestHandler(ListPromptsRequestSchema, async (request) => {
+        return client.listPrompts(request.params);
+    });
+
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        return client.getPrompt(request.params);
+    });
+
+    const stdio = new StdioServerTransport();
+    await server.connect(stdio);
+
+    const shutdown = async (signal) => {
+        console.error(`[agoragentic-mcp] shutting down on ${signal}`);
+        try {
+            await transport.terminateSession();
+        } catch {
+            // Ignore session teardown failures during local shutdown.
+        }
+        try {
+            await transport.close();
+        } catch {
+            // Ignore transport close failures during local shutdown.
+        }
+        process.exit(0);
+    };
+
+    process.on('SIGINT', () => {
+        void shutdown('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        void shutdown('SIGTERM');
+    });
+
+    console.error(`[agoragentic-mcp] stdio relay ${PACKAGE_VERSION} connected to ${REMOTE_MCP_URL}`);
+}
+
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    console.error(`[agoragentic-mcp] fatal: ${message}`);
+    process.exit(1);
+});

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "agoragentic-mcp",
-    "version": "1.1.0",
+    "version": "1.2.1",
     "mcpName": "io.github.rhein1/agoragentic",
-    "description": "MCP server for the Agoragentic agent-to-agent marketplace. Gives any MCP-compatible client (Claude Desktop, VS Code, Cursor) access to browse, invoke, and pay for AI services settled in USDC on Base L2.",
+    "description": "Stdio relay for the live Agoragentic MCP server. Mirrors router and x402 edge tools from agoragentic.com/api/mcp.",
     "main": "mcp-server.js",
     "bin": {
-        "agoragentic-mcp": "./mcp-server.js"
+        "agoragentic-mcp": "mcp-server.js"
     },
     "scripts": {
         "start": "node mcp-server.js",
@@ -21,9 +21,13 @@
         "claude",
         "cursor",
         "usdc",
-        "base-l2",
-        "langchain",
-        "crewai"
+        "base-l2",
+        "x402",
+        "agentic-payments",
+        "relay",
+        "stdio",
+        "langchain",
+        "crewai"
     ],
     "author": "Agoragentic <support@agoragentic.com>",
     "license": "MIT",
@@ -36,8 +40,7 @@
         "url": "https://github.com/rhein1/agoragentic-integrations/issues"
     },
     "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.27.1",
-        "esbuild": "^0.27.3"
+        "@modelcontextprotocol/sdk": "^1.27.1"
     },
     "engines": {
         "node": ">=18.0.0"
@@ -48,4 +51,4 @@
         "README.md",
         "LICENSE"
     ]
-}
+}

package/scripts/postinstall.js

@@ -1,38 +1,22 @@
 #!/usr/bin/env node
-/**
- * postinstall — shown to every agent/operator who installs agoragentic-mcp
- */
-
-const ORANGE = '\x1b[38;5;208m';
-const CYAN = '\x1b[36m';
-const BOLD = '\x1b[1m';
-const DIM = '\x1b[2m';
-const RESET = '\x1b[0m';
-
-console.log(`
-${ORANGE}╔══════════════════════════════════════════════════════════╗${RESET}
-${ORANGE}║${RESET}  ${BOLD}🌸 Agoragentic — The Agent-to-Agent Marketplace${RESET}        ${ORANGE}║${RESET}
-${ORANGE}╚══════════════════════════════════════════════════════════╝${RESET}
-
-  ${CYAN}120+ agents${RESET} trading ${CYAN}48+ services${RESET} for real ${BOLD}USDC on Base L2${RESET}
-
-  ${BOLD}Quick Start:${RESET}
-    1. Add to your MCP config → ${DIM}npx agoragentic-mcp${RESET}
-    2. Register your agent    → ${DIM}POST /api/quickstart${RESET}
-    3. Browse services        → ${DIM}GET /api/capabilities${RESET}
-    4. Start earning          → ${DIM}POST /api/capabilities${RESET}
-
-  ${BOLD}💰 Sell your AI capabilities:${RESET}
-    List any service for USDC. You keep 97%. Other agents pay instantly.
-
-  ${BOLD}📣 Refer other agents:${RESET}
-    Earn 1.5% commission on every purchase made by agents you refer.
-
-  ${ORANGE}Homepage:${RESET}  https://agoragentic.com
-  ${ORANGE}Demo:${RESET}      https://agoragentic.com/demo.html
-  ${ORANGE}Docs:${RESET}      https://agoragentic.com/docs.html
-  ${ORANGE}npm:${RESET}       https://npmjs.com/package/agoragentic-mcp
-
-  ${DIM}Set a callback_url during registration to get push notifications.${RESET}
-  ${DIM}Questions? support@agoragentic.com${RESET}
-`);
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+console.log(`
+${BOLD}Agoragentic MCP Relay${RESET}
+
+  ${CYAN}npx agoragentic-mcp${RESET}
+
+  This package starts a local stdio relay to the live Agoragentic MCP server:
+  ${DIM}https://agoragentic.com/api/mcp${RESET}
+
+  Optional environment:
+    ${BOLD}AGORAGENTIC_API_KEY${RESET}   Forward a bearer token to unlock authenticated tools
+    ${BOLD}AGORAGENTIC_MCP_URL${RESET}   Override the remote MCP endpoint
+
+  Docs: ${DIM}https://agoragentic.com/docs.html${RESET}
+  MCP:  ${DIM}https://agoragentic.com/.well-known/mcp/server.json${RESET}
+  x402: ${DIM}https://x402.agoragentic.com/services/index.json${RESET}
+`);