agoragentic-mcp 1.2.0 → 1.3.0

package/README.md

@@ -87,8 +87,8 @@ File: `~/.codeium/windsurf/mcp_config.json`
 npx agoragentic-mcp
 ```
 
-## Available Tools
-
+## Available Tools
+
 | Tool | Description | Auth Required |
 |------|-------------|---------------|
 | `agoragentic_browse_services` | Browse stable anonymous x402 services on the dedicated edge | No |
@@ -100,11 +100,6 @@ npx agoragentic-mcp
 | `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_passport` | Check passport info or verify a Base wallet | No/Yes |
 
 ## Stable x402 Flow
 
@@ -115,6 +110,11 @@ The simplest anonymous paid flow is:
 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 `Payment-Receipt` plus the JSON result.
+| `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
 

package/mcp-server.js

@@ -30,24 +30,22 @@
 
 const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
 const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
-const {
-    CallToolRequestSchema,
-    ListToolsRequestSchema,
-    ListResourcesRequestSchema,
-    ReadResourceRequestSchema,
-    ListPromptsRequestSchema,
-    GetPromptRequestSchema,
-    McpError,
-} = require("@modelcontextprotocol/sdk/types.js");
-
-const AGORAGENTIC_BASE = "https://agoragentic.com";
-const X402_EDGE_BASE = "https://x402.agoragentic.com";
-const API_KEY = process.env.AGORAGENTIC_API_KEY || "";
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+} = 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}`;
+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}`;
 
@@ -62,145 +60,8 @@ async function apiCall(method, path, body = null) {
         return resp.json();
     } finally {
         clearTimeout(timeout);
-    }
-}
-
-async function edgeRequest(method, path, body = null, extraHeaders = {}) {
-    const url = `${X402_EDGE_BASE}${path}`;
-    const headers = { ...extraHeaders };
-
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 30000);
-
-    try {
-        const options = { method, headers, signal: controller.signal };
-        if (body !== null && body !== undefined) {
-            options.headers["Content-Type"] = "application/json";
-            options.body = JSON.stringify(body);
-        }
-
-        const resp = await fetch(url, options);
-        const raw = await resp.text();
-        return { response: resp, data: parseMaybeJson(raw) };
-    } finally {
-        clearTimeout(timeout);
-    }
-}
-
-function parseMaybeJson(text) {
-    if (!text) return null;
-    try {
-        return JSON.parse(text);
-    } catch {
-        return text;
-    }
-}
-
-function slugifyService(value) {
-    return String(value || "")
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-}
-
-function findEdgeService(services, slug) {
-    const wanted = slugifyService(slug);
-    if (!wanted) return null;
-    return (services || []).find((service) => {
-        const aliases = [service?.slug, ...(service?.route_aliases || [])]
-            .map(slugifyService)
-            .filter(Boolean);
-        return aliases.includes(wanted);
-    }) || null;
-}
-
-function decodeBase64JsonHeader(value) {
-    if (!value || typeof value !== "string") return null;
-    try {
-        return JSON.parse(Buffer.from(value, "base64").toString("utf8"));
-    } catch {
-        return null;
-    }
-}
-
-function buildMcpPaymentRequiredData({ toolName, args, response, routing = null, trust = null }) {
-    const paymentRequiredHeader = response.headers.get("payment-required") || null;
-    const decodedRequirements = decodeBase64JsonHeader(paymentRequiredHeader);
-    const challenges = Array.isArray(decodedRequirements)
-        ? decodedRequirements.map((challenge, index) => ({
-            id: challenge?.extra?.quote_id || `challenge_${index + 1}`,
-            method: challenge?.scheme || "exact",
-            intent: "charge",
-            network: challenge?.network || null,
-            resource: challenge?.resource || null,
-            request: {
-                max_amount_required: challenge?.maxAmountRequired || null,
-                asset: challenge?.asset || null,
-                pay_to: challenge?.payTo || null,
-                description: challenge?.description || null,
-                extra: challenge?.extra || null,
-            },
-        }))
-        : [];
-
-    return {
-        protocol: "x402",
-        payment_required_header: paymentRequiredHeader,
-        authenticate_header: response.headers.get("www-authenticate") || null,
-        challenges,
-        routing,
-        trust,
-        retry_tool_call: {
-            name: toolName,
-            arguments: {
-                ...(args || {}),
-                payment_signature: "<PAYMENT-SIGNATURE>",
-            },
-            payment_argument: "payment_signature",
-            accepted_http_headers: ["PAYMENT-SIGNATURE", "Authorization: Payment"],
-        },
-    };
-}
-
-function buildMcpPaymentSuccessBody(response, body) {
-    return {
-        status_code: response.status,
-        payment_receipt: response.headers.get("payment-receipt") || null,
-        payment_response_header: response.headers.get("payment-response") || null,
-        body,
-    };
-}
-
-function summarizeEdgeService(service, options = {}) {
-    const includeSchemas = options.includeSchemas === true;
-    const includeTrust = options.includeTrust !== false;
-    return {
-        slug: service.slug,
-        name: service.name,
-        description: service.description,
-        category: service.category,
-        status: service.status,
-        price_usdc: service.price_usdc,
-        payable_url: service.payable_url,
-        route_aliases: service.route_aliases || [],
-        safe_to_retry: service.execution_contract?.safe_to_retry ?? service.trust?.safe_to_retry ?? null,
-        max_runtime_ms: service.execution_contract?.max_runtime_ms ?? service.trust?.max_runtime_ms ?? null,
-        payment_contract: service.payment_contract || null,
-        sample_input: service.sample_input || null,
-        trust: includeTrust ? (service.trust || null) : undefined,
-        input_schema: includeSchemas ? (service.input_schema || null) : undefined,
-        output_schema: includeSchemas ? (service.output_schema || null) : undefined,
-    };
-}
-
-async function loadEdgeServices() {
-    const { response, data } = await edgeRequest("GET", "/services/index.json");
-    if (!response.ok) {
-        throw new Error(`x402 edge service index failed with HTTP ${response.status}`);
-    }
-    return Array.isArray(data?.services) ? data.services : [];
-}
+    }
+}
 
 // ─── MCP Server ──────────────────────────────────────────
 
@@ -211,69 +72,15 @@ const server = new Server(
 
 // ─── Tools ───────────────────────────────────────────────
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
+// Extracted so both MCP and ACP modes can share the same definitions
+function getToolList() {
+    return [
         // ── Core Marketplace ──
-        {
-            name: "agoragentic_browse_services",
-            description: "Browse stable anonymous x402 services on x402.agoragentic.com. Use this as the accountless buyer catalog for bounded paid resources.",
-            annotations: { title: "Browse x402 Services", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    limit: { type: "number", default: 10, description: "Maximum number of services to return." },
-                    include_schemas: { type: "boolean", default: false, description: "Include full input/output schemas in the response." },
-                    include_trust: { type: "boolean", default: true, description: "Include trust and settlement metadata in the response." }
-                }
-            }
-        },
-        {
-            name: "agoragentic_quote_service",
-            description: "Quote one stable x402 service by slug. Returns price, retry behavior, trust metadata, sample input, and the exact payable URL without spending.",
-            annotations: { title: "Quote x402 Service", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    slug: { type: "string", description: "Stable x402 service slug, for example text-summarizer." },
-                    max_price_usdc: { type: "number", description: "Optional safety bound. The tool errors if the quoted service exceeds this price." },
-                    include_schemas: { type: "boolean", default: true, description: "Include full input/output schemas in the response." },
-                    include_trust: { type: "boolean", default: true, description: "Include trust and settlement metadata in the response." }
-                },
-                required: ["slug"]
-            }
-        },
-        {
-            name: "agoragentic_call_service",
-            description: "Call one stable x402 service by slug. The first unpaid attempt returns an x402 Payment Required payload. Retry the same tool call with payment_signature to complete the paid call.",
-            annotations: { title: "Call x402 Service", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    slug: { type: "string", description: "Stable x402 service slug, for example text-summarizer." },
-                    payload: { type: "object", description: "JSON payload sent to the stable edge route.", default: {} },
-                    payment_signature: { type: "string", description: "Optional PAYMENT-SIGNATURE value used on the paid retry." },
-                    max_price_usdc: { type: "number", description: "Optional safety bound. The tool errors if the quoted service exceeds this price." }
-                },
-                required: ["slug"]
-            }
-        },
-        {
-            name: "agoragentic_edge_receipt",
-            description: "Fetch one anonymous x402 edge receipt by receipt ID from x402.agoragentic.com.",
-            annotations: { title: "Get x402 Edge Receipt", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    receipt_id: { type: "string", description: "Stable edge receipt identifier, usually returned in the Payment-Receipt header." }
-                },
-                required: ["receipt_id"]
-            }
-        },
-        {
-            name: "agoragentic_register",
-            description: "Register as a new agent on Agoragentic. Returns an API key and access to the Starter Pack. Starter pack rewards are fee discounts, not free credits.",
-            annotations: { title: "Register Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-            inputSchema: {
+        {
+            name: "agoragentic_register",
+            description: "Register as a new agent on Agoragentic. Returns an API key and access to the Starter Pack. Starter pack rewards are fee discounts, not free credits.",
+            annotations: { title: "Register Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+            inputSchema: {
                 type: "object",
                 properties: {
                     agent_name: { type: "string", description: "Your agent's display name (must be unique across the marketplace)" },
@@ -404,185 +211,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 }
             }
         }
-    ]
-}));
+    ];
+}
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: getToolList() }));
 
-    try {
-        switch (name) {
-            case "agoragentic_browse_services": {
-                const services = await loadEdgeServices();
-                const limit = Math.max(1, Math.min(Number(args.limit) || 10, 50));
-                const summaries = services
-                    .filter((service) => service && service.status === "available")
-                    .slice(0, limit)
-                    .map((service) => summarizeEdgeService(service, {
-                        includeSchemas: args.include_schemas === true,
-                        includeTrust: args.include_trust !== false,
-                    }));
-
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            mode: "anonymous_x402_edge",
-                            service_count: summaries.length,
-                            base_url: X402_EDGE_BASE,
-                            services: summaries,
-                        }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_quote_service": {
-                const services = await loadEdgeServices();
-                const service = findEdgeService(services, args.slug);
-                if (!service) {
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "unknown_service",
-                                slug: args.slug || null,
-                                message: "Stable x402 service slug not found on the edge."
-                            }, null, 2)
-                        }],
-                        isError: true
-                    };
-                }
-
-                const quotedPrice = Number.parseFloat(service.price_usdc);
-                if (Number.isFinite(Number(args.max_price_usdc)) && Number.isFinite(quotedPrice) && quotedPrice > Number(args.max_price_usdc)) {
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "price_exceeds_max",
-                                slug: service.slug,
-                                quoted_price_usdc: service.price_usdc,
-                                max_price_usdc: Number(args.max_price_usdc)
-                            }, null, 2)
-                        }],
-                        isError: true
-                    };
-                }
-
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            mode: "anonymous_x402_edge_quote",
-                            ...summarizeEdgeService(service, {
-                                includeSchemas: args.include_schemas !== false,
-                                includeTrust: args.include_trust !== false,
-                            })
-                        }, null, 2)
-                    }]
-                };
-            }
-
-            case "agoragentic_call_service": {
-                const services = await loadEdgeServices();
-                const service = findEdgeService(services, args.slug);
-                if (!service) {
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "unknown_service",
-                                slug: args.slug || null,
-                                message: "Stable x402 service slug not found on the edge."
-                            }, null, 2)
-                        }],
-                        isError: true
-                    };
-                }
-
-                const quotedPrice = Number.parseFloat(service.price_usdc);
-                if (Number.isFinite(Number(args.max_price_usdc)) && Number.isFinite(quotedPrice) && quotedPrice > Number(args.max_price_usdc)) {
-                    return {
-                        content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "price_exceeds_max",
-                                slug: service.slug,
-                                quoted_price_usdc: service.price_usdc,
-                                max_price_usdc: Number(args.max_price_usdc)
-                            }, null, 2)
-                        }],
-                        isError: true
-                    };
-                }
-
-                const requestHeaders = {};
-                if (args.payment_signature) {
-                    requestHeaders["PAYMENT-SIGNATURE"] = String(args.payment_signature);
-                }
-
-                const { response, data } = await edgeRequest(
-                    "POST",
-                    `/v1/${encodeURIComponent(service.slug)}`,
-                    args.payload || {},
-                    requestHeaders
-                );
-
-                if (response.status === 402) {
-                    throw new McpError(-32042, "Payment Required", buildMcpPaymentRequiredData({
-                        toolName: "agoragentic_call_service",
-                        args: {
-                            slug: service.slug,
-                            payload: args.payload || {},
-                            max_price_usdc: args.max_price_usdc
-                        },
-                        response,
-                        routing: {
-                            provider_count: 1,
-                            selected_provider: service.slug,
-                            route: `/v1/${service.slug}`,
-                        },
-                        trust: service.trust || {
-                            status: service.status || "reachable",
-                            method: "x402_edge_service_index",
-                        }
-                    }));
-                }
-
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            slug: service.slug,
-                            service_name: service.name,
-                            payable_url: service.payable_url,
-                            ...buildMcpPaymentSuccessBody(response, data)
-                        }, null, 2)
-                    }],
-                    isError: response.status >= 400
-                };
-            }
-
-            case "agoragentic_edge_receipt": {
-                const { response, data } = await edgeRequest(
-                    "GET",
-                    `/v1/receipts/${encodeURIComponent(String(args.receipt_id || ""))}`
-                );
-                return {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            status_code: response.status,
-                            receipt: data
-                        }, null, 2)
-                    }],
-                    isError: response.status >= 400
-                };
-            }
-
-            case "agoragentic_register": {
-                const data = await apiCall("POST", "/api/quickstart", {
-                    name: args.agent_name,
+// Extracted so both MCP and ACP modes can share the same execution logic
+async function executeToolCall(name, args) {
+
+    try {
+        switch (name) {
+            case "agoragentic_register": {
+                const data = await apiCall("POST", "/api/quickstart", {
+                    name: args.agent_name,
                     type: args.agent_type || "both"
                 });
                 return {
@@ -840,6 +481,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     } catch (err) {
         return { content: [{ type: "text", text: `Error: ${err.message}` }] };
     }
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return executeToolCall(name, args);
 });
 
 // ─── Resources ───────────────────────────────────────────
@@ -1004,12 +650,137 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     throw new Error(`Unknown prompt: ${name}`);
 });
 
+// ─── ACP Mode ────────────────────────────────────────────
+//
+// When started with --acp, the server speaks the Agent Client Protocol
+// (JSON-RPC 2.0 over stdio) instead of MCP. This enables integration
+// with ACP-compatible editors like Zed, JetBrains, VS Code via Copilot, etc.
+//
+// The ACP handshake adds: protocolVersion, agentCapabilities, agentInfo, authMethods
+// Tool definitions and execution are identical to MCP mode.
+
+const ACP_MODE = process.argv.includes("--acp");
+
+function createAcpServer() {
+    const readline = require("readline");
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+    });
+
+    function send(obj) {
+        process.stdout.write(JSON.stringify(obj) + "\n");
+    }
+
+    function sendResult(id, result) {
+        send({ jsonrpc: "2.0", id, result });
+    }
+
+    function sendError(id, code, message, data) {
+        send({ jsonrpc: "2.0", id, error: { code, message, ...(data ? { data } : {}) } });
+    }
+
+    // ACP initialize response with auth methods
+    function handleInitialize(id, params) {
+        sendResult(id, {
+            protocolVersion: params?.protocolVersion || 1,
+            agentCapabilities: {
+                loadSession: false,
+                promptCapabilities: { image: false, audio: false },
+            },
+            agentInfo: {
+                name: "agoragentic",
+                version: "2.0.0",
+                description: "Agoragentic agent marketplace — 174+ AI capabilities, USDC payments on Base L2",
+            },
+            authMethods: API_KEY
+                ? []  // Already authenticated via env var
+                : [
+                    {
+                        type: "terminal",
+                        description: "Set AGORAGENTIC_API_KEY environment variable. Get a key via the agoragentic_register tool.",
+                    },
+                ],
+        });
+    }
+
+    rl.on("line", async (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line.trim());
+        } catch {
+            sendError(null, -32700, "Parse error");
+            return;
+        }
+
+        if (msg.jsonrpc !== "2.0") {
+            sendError(msg.id || null, -32600, "Invalid JSON-RPC version");
+            return;
+        }
+
+        try {
+            switch (msg.method) {
+                case "initialize":
+                    handleInitialize(msg.id, msg.params);
+                    break;
+
+                case "initialized":
+                    // ACP notification — no response needed
+                    break;
+
+                case "tools/list":
+                    sendResult(msg.id, {
+                        tools: getToolList().map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: t.inputSchema,
+                            annotations: t.annotations,
+                        })),
+                    });
+                    break;
+
+                case "tools/call": {
+                    const { name, arguments: callArgs } = msg.params || {};
+                    const result = await executeToolCall(name, callArgs || {});
+                    sendResult(msg.id, result);
+                    break;
+                }
+
+                case "shutdown":
+                    sendResult(msg.id, { success: true });
+                    setTimeout(() => process.exit(0), 100);
+                    break;
+
+                default:
+                    sendError(msg.id, -32601, `Method not found: ${msg.method}`);
+            }
+        } catch (err) {
+            if (err.code === -32042) {
+                // x402 Payment Required — forward structured data
+                sendError(msg.id, -32042, err.message, err.data);
+            } else {
+                sendError(msg.id, -32603, err.message || "Internal error");
+            }
+        }
+    });
+
+    rl.on("close", () => process.exit(0));
+
+    console.error("Agoragentic ACP Agent v2.0 running on stdio (ACP mode)");
+}
+
 // ─── Start ───────────────────────────────────────────────
 
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Agoragentic MCP Server v2.0 running on stdio");
+    if (ACP_MODE) {
+        createAcpServer();
+    } else {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error("Agoragentic MCP Server v2.0 running on stdio");
+    }
 }
 
 main().catch(console.error);

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "agoragentic-mcp",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "mcpName": "io.github.rhein1/agoragentic",
-    "description": "MCP server for Agoragentic. Gives MCP clients access to registered marketplace tools and stable x402 edge services settled in USDC on Base.",
+    "description": "MCP and ACP server for the Agoragentic agent-to-agent marketplace. Gives any MCP or ACP-compatible client (Claude Desktop, VS Code, Cursor, Zed, JetBrains) access to browse, invoke, and pay for AI services settled in USDC on Base L2.",
     "main": "mcp-server.js",
     "bin": {
         "agoragentic-mcp": "./mcp-server.js"
@@ -21,11 +21,11 @@
         "claude",
         "cursor",
         "usdc",
-        "base-l2",
-        "x402",
-        "agentic-payments",
-        "langchain",
-        "crewai"
+        "base-l2",
+        "langchain",
+        "crewai",
+        "acp",
+        "agent-client-protocol"
     ],
     "author": "Agoragentic <support@agoragentic.com>",
     "license": "MIT",
@@ -50,4 +50,4 @@
         "README.md",
         "LICENSE"
     ]
-}
+}