agoragentic-mcp 1.3.0 → 1.3.2

package/mcp-server.js

@@ -1,787 +1,626 @@
 #!/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,
-    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}`;
-    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);
+'use strict';
+
+const readline = require('readline');
+const crypto = require('crypto');
+const { version: PACKAGE_VERSION } = require('./package.json');
+
+const REMOTE_MCP_URL = process.env.AGORAGENTIC_MCP_URL || 'https://agoragentic.com/api/mcp';
+const AGORAGENTIC_BASE = process.env.AGORAGENTIC_BASE_URL || 'https://agoragentic.com';
+const API_KEY = process.env.AGORAGENTIC_API_KEY || '';
+const ACP_MODE = process.argv.includes('--acp');
+
+const ACP_TOOLS = [
+    {
+        name: 'agoragentic_execute',
+        description: 'Route a task through Agent OS execute() with provider selection, fallback, receipts, and settlement.',
+    },
+    {
+        name: 'agoragentic_match',
+        description: 'Preview routed providers before execution.',
+    },
+    {
+        name: 'agoragentic_quote',
+        description: 'Create a bounded quote before paid execution.',
+    },
+    {
+        name: 'agoragentic_status',
+        description: 'Inspect execution status for an invocation.',
+    },
+    {
+        name: 'agoragentic_receipt',
+        description: 'Fetch normalized receipt and settlement metadata.',
+    },
+    {
+        name: 'agoragentic_browse_services',
+        description: 'Browse stable x402 edge resources.',
+    },
+    {
+        name: 'agoragentic_call_service',
+        description: 'Call a stable x402 edge resource after payment challenge handling.',
+    },
+    {
+        name: 'agoragentic_edge_receipt',
+        description: 'Inspect x402 edge receipt metadata.',
+    },
+    {
+        name: 'agoragentic_x402_test',
+        description: 'Exercise the free x402 pipeline canary.',
+    },
+];
+
+function buildJsonContent(data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof data === 'string' ? data : JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+
+async function apiCall(method, path, body) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'User-Agent': `agoragentic-mcp/${PACKAGE_VERSION}`,
+    };
+    if (API_KEY) {
+        headers.Authorization = `Bearer ${API_KEY}`;
+    }
+
+    const response = await fetch(`${AGORAGENTIC_BASE}${path}`, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+
+    const text = await response.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    } catch {
+        data = { raw: text };
+    }
+
+    if (!response.ok) {
+        return {
+            ok: false,
+            status: response.status,
+            error: data.error || data.message || response.statusText,
+            details: data,
+        };
+    }
+
+    return data;
+}
+
+function requireApiKey() {
+    if (API_KEY) return null;
+    return buildJsonContent({
+        ok: false,
+        error: 'missing_api_key',
+        message: 'Set AGORAGENTIC_API_KEY for authenticated Router / Marketplace execution tools. Use agoragentic_register to create a key.',
+    });
+}
+
+function buildFallbackToolList() {
+    return [
+        {
+            name: 'agoragentic_register',
+            description: 'Register an agent with Agoragentic and receive an API key for routed execution.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Agent name' },
+                    agent_name: { type: 'string', description: 'Agent name, compatibility alias' },
+                    intent: { type: 'string', description: 'buyer, seller, or both', default: 'buyer' },
+                    description: { type: 'string', description: 'Short agent description' },
+                },
+            },
+        },
+        {
+            name: 'agoragentic_search',
+            description: 'Search public Agoragentic marketplace capabilities.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    category: { type: 'string', description: 'Optional category filter' },
+                    limit: { type: 'number', description: 'Maximum results to return', default: 10 },
+                },
+            },
+        },
+        {
+            name: 'agoragentic_match',
+            description: 'Preview Router / Marketplace provider matches for a task. No spend.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'Task to route' },
+                    max_cost: { type: 'number', description: 'Maximum USDC price per call' },
+                    category: { type: 'string', description: 'Optional category filter' },
+                    prefer_trusted: { type: 'boolean', description: 'Prefer trusted providers', default: true },
+                },
+                required: ['task'],
+            },
+        },
+        {
+            name: 'agoragentic_execute',
+            description: 'Execute a task through the hosted Agoragentic Router / Marketplace. May spend according to listing price and account balance.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'Task to execute' },
+                    input: { type: 'object', description: 'Provider input payload', default: {} },
+                    constraints: { type: 'object', description: 'Routing and budget constraints', default: {} },
+                    quote_id: { type: 'string', description: 'Optional quote ID' },
+                    intent_contract_id: { type: 'string', description: 'Optional Agent OS intent contract ID' },
+                },
+                required: ['task'],
+            },
+        },
+        {
+            name: 'agoragentic_execute_status',
+            description: 'Read status, output, cost, and receipt metadata for a routed execution.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    invocation_id: { type: 'string', description: 'Invocation ID from agoragentic_execute' },
+                },
+                required: ['invocation_id'],
+            },
+        },
+    ];
+}
+
+function mergeFallbackTools(remoteTools = []) {
+    const seen = new Set(remoteTools.map((tool) => tool.name));
+    const merged = [...remoteTools];
+    for (const tool of buildFallbackToolList()) {
+        if (!seen.has(tool.name)) {
+            merged.push(tool);
+        }
+    }
+    return merged;
+}
+
+async function executeFallbackTool(name, args = {}) {
+    if (name === 'agoragentic_register') {
+        const agentName = args.agent_name || args.name || 'mcp-agent';
+        const data = await apiCall('POST', '/api/quickstart', {
+            name: agentName,
+            intent: args.intent || 'buyer',
+            description: args.description || 'Registered through agoragentic-mcp fallback tools.',
+        });
+        return buildJsonContent(data);
+    }
+
+    if (name === 'agoragentic_search') {
+        const params = new URLSearchParams();
+        if (args.query) params.set('q', args.query);
+        if (args.category) params.set('category', args.category);
+        if (args.limit !== undefined) params.set('limit', String(args.limit));
+        const data = await apiCall('GET', `/api/capabilities?${params.toString()}`);
+        return buildJsonContent(data);
+    }
+
+    if (name === 'agoragentic_match') {
+        const missing = requireApiKey();
+        if (missing) return missing;
+        const params = new URLSearchParams();
+        params.set('task', args.task);
+        if (args.max_cost !== undefined) params.set('max_cost', String(args.max_cost));
+        if (args.category) params.set('category', args.category);
+        if (args.prefer_trusted !== undefined) params.set('prefer_trusted', args.prefer_trusted ? 'true' : 'false');
+        const data = await apiCall('GET', `/api/execute/match?${params.toString()}`);
+        return buildJsonContent(data);
+    }
+
+    if (name === 'agoragentic_execute') {
+        const missing = requireApiKey();
+        if (missing) return missing;
+        const payload = {
+            task: args.task,
+            input: args.input || {},
+            constraints: args.constraints || {},
+        };
+        if (args.quote_id) payload.quote_id = args.quote_id;
+        if (args.intent_contract_id) payload.intent_contract_id = args.intent_contract_id;
+        const data = await apiCall('POST', '/api/execute', payload);
+        return buildJsonContent(data);
+    }
+
+    if (name === 'agoragentic_execute_status') {
+        const missing = requireApiKey();
+        if (missing) return missing;
+        const invocationId = String(args.invocation_id || '').replace(/[^a-zA-Z0-9\-_]/g, '');
+        if (!invocationId) return buildJsonContent({ ok: false, error: 'invalid_invocation_id' });
+        const data = await apiCall('GET', `/api/execute/status/${invocationId}`);
+        return buildJsonContent(data);
+    }
+
+    return buildJsonContent({
+        ok: false,
+        error: 'unknown_tool',
+        tool: name,
+    });
+}
+
+function buildRemoteTransport() {
+    const { StreamableHTTPClientTransport } = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+    const headers = {};
+    if (API_KEY) {
+        headers.Authorization = `Bearer ${API_KEY}`;
     }
-}
-
-// ─── MCP Server ──────────────────────────────────────────
-
-const server = new Server(
-    { name: "agoragentic", version: "2.0.0" },
-    { capabilities: { tools: {}, resources: {}, prompts: {} } }
-);
-
-// ─── Tools ───────────────────────────────────────────────
-
-// Extracted so both MCP and ACP modes can share the same definitions
-function getToolList() {
-    return [
-        // ── Core Marketplace ──
-        {
-            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)" },
-                    agent_type: { type: "string", enum: ["buyer", "seller", "both"], default: "both", description: "Agent role: buyer (consume services), seller (provide services), or both" }
-                },
-                required: ["agent_name"]
-            }
-        },
-        {
-            name: "agoragentic_search",
-            description: "Search Agoragentic for agent capabilities. Find tools, services, datasets, and skills available through the capability router. Returns names, descriptions, prices (USDC), and IDs you can use to invoke them.",
-            annotations: { title: "Search Capabilities", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: { type: "string", description: "Search term to filter capabilities (e.g., 'summarize', 'translate', 'research')" },
-                    category: { type: "string", description: "Category filter (e.g., research, creative, data, agent-upgrades, infrastructure)" },
-                    max_price: { type: "number", description: "Maximum price in USDC to filter results by cost" },
-                    limit: { type: "number", default: 10, description: "Maximum number of results to return (1 to 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.",
-            annotations: { title: "Invoke Capability", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    capability_id: { type: "string", description: "The capability ID returned from a search result" },
-                    input: { type: "object", description: "Input payload for the capability as a JSON object", 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.",
-            annotations: { title: "View Vault", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    item_type: { type: "string", description: "Filter by item type: skill, digital_asset, nft, license, subscription, or collectible" },
-                    include_nfts: { type: "boolean", description: "Include on-chain NFTs minted on Base L2 blockchain", default: false },
-                    limit: { type: "number", default: 20, description: "Maximum number of vault items to return" }
-                }
-            }
-        },
-        {
-            name: "agoragentic_categories",
-            description: "List all available marketplace categories and how many capabilities are in each.",
-            annotations: { title: "List Categories", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            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.",
-            annotations: { title: "Write Memory", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    key: { type: "string", description: "Memory key identifier, maximum 256 characters" },
-                    value: { type: "string", description: "Value to store, maximum 64KB. Can be any string or serialized JSON." },
-                    namespace: { type: "string", default: "default", description: "Namespace to organize keys into logical groups" },
-                    ttl_seconds: { type: "number", description: "Automatic expiration in seconds. Omit for permanent storage." }
-                },
-                required: ["key", "value"]
-            }
+    return new StreamableHTTPClientTransport(new URL(REMOTE_MCP_URL), {
+        requestInit: {
+            headers,
         },
-        {
-            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.",
-            annotations: { title: "Read Memory", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    key: { type: "string", description: "Specific key to read. Omit to list all stored keys." },
-                    namespace: { type: "string", default: "default", description: "Namespace to read from" },
-                    prefix: { type: "string", description: "Filter keys by prefix when listing all keys" }
-                }
-            }
-        },
-
-        // ── 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.",
-            annotations: { title: "Store Secret", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    label: { type: "string", description: "Label for the secret, for example 'openai_key' or 'stripe_token'" },
-                    secret: { type: "string", description: "The secret value to encrypt and store securely" },
-                    hint: { type: "string", description: "Optional human readable hint to help you remember what this secret is for" }
-                },
-                required: ["label", "secret"]
-            }
-        },
-        {
-            name: "agoragentic_secret_retrieve",
-            description: "Retrieve a decrypted secret from your vault. Free, no cost to access your own credentials.",
-            annotations: { title: "Retrieve Secret", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    label: { type: "string", description: "Label of the secret to retrieve. Omit to list all stored secrets." }
-                }
-            }
-        },
-
-        // ── 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.",
-            annotations: { title: "Agent Passport", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-            inputSchema: {
-                type: "object",
-                properties: {
-                    action: {
-                        type: "string",
-                        enum: ["check", "info", "verify"],
-                        default: "check",
-                        description: "Action to perform: check your passport status, info for system overview, or verify a wallet address"
-                    },
-                    wallet_address: { type: "string", description: "Wallet address to verify ownership. Only used when action is set to verify." }
-                }
-            }
-        }
-    ];
+    });
 }
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: getToolList() }));
-
-// 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 {
-                    content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            status: "registered",
-                            agent_id: data.agent?.id,
-                            api_key: data.api_key,
-                            fee_rate: "3.00%",
-                            message: "Save your API key! Set it as AGORAGENTIC_API_KEY environment variable.",
-                            next: "Use agoragentic_search to find capabilities, or agoragentic_invoke to call one directly"
-                        }, 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}` }] };
-    }
+async function connectRemoteClient() {
+    const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+    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 };
 }
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return executeToolCall(name, args);
-});
-
-// ─── 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}`);
-});
+async function runMcpRelay() {
+    const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+    const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+    const {
+        CallToolRequestSchema,
+        ListToolsRequestSchema,
+        ListResourcesRequestSchema,
+        ReadResourceRequestSchema,
+        ListPromptsRequestSchema,
+        GetPromptRequestSchema,
+    } = require('@modelcontextprotocol/sdk/types.js');
+
+    const server = new Server(
+        { name: 'agoragentic', version: PACKAGE_VERSION },
+        { capabilities: { tools: {}, resources: {}, prompts: {} } }
+    );
+
+    let remoteSession = null;
+    try {
+        remoteSession = await connectRemoteClient();
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[agoragentic-mcp] remote relay unavailable, using local fallback tools: ${message}`);
+    }
+
+    if (remoteSession) {
+        const { client } = remoteSession;
+        server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+            const result = await client.listTools(request.params);
+            return {
+                ...result,
+                tools: mergeFallbackTools(result.tools),
+            };
+        });
+
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            if (
+                request.params.name === 'agoragentic_match' ||
+                request.params.name === 'agoragentic_execute' ||
+                request.params.name === 'agoragentic_execute_status'
+            ) {
+                return executeFallbackTool(request.params.name, request.params.arguments || {});
+            }
+            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);
+        });
+    } else {
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return { tools: buildFallbackToolList() };
+        });
+
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            return executeFallbackTool(request.params.name, request.params.arguments || {});
+        });
+
+        server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            return { resources: [] };
+        });
+
+        server.setRequestHandler(ReadResourceRequestSchema, async () => {
+            throw new Error('Resources are unavailable while the remote Agoragentic MCP relay is unreachable.');
+        });
+
+        server.setRequestHandler(ListPromptsRequestSchema, async () => {
+            return { prompts: [] };
+        });
+
+        server.setRequestHandler(GetPromptRequestSchema, async () => {
+            throw new Error('Prompts are unavailable while the remote Agoragentic MCP relay is unreachable.');
+        });
+    }
+
+    const stdio = new StdioServerTransport();
+    await server.connect(stdio);
+
+    const shutdown = async (signal) => {
+        console.error(`[agoragentic-mcp] shutting down on ${signal}`);
+        if (remoteSession) {
+            try {
+                await remoteSession.transport.terminateSession();
+            } catch {
+                // Ignore session teardown failures during local shutdown.
+            }
+            try {
+                await remoteSession.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');
+    });
 
-// ─── Prompts ─────────────────────────────────────────────
-
-server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: [
-        {
-            name: "quickstart",
-            description: "Get started with Agoragentic. Walks you through registration, searching for capabilities, and making your first invocation.",
-            arguments: [
-                { name: "agent_name", description: "Name for your new agent", required: true },
-                { name: "task", description: "What you want to accomplish (e.g., 'summarize documents', 'translate text')", required: false }
-            ]
+    if (remoteSession) {
+        console.error(`[agoragentic-mcp] stdio relay ${PACKAGE_VERSION} connected to ${REMOTE_MCP_URL}`);
+    } else {
+        console.error(`[agoragentic-mcp] stdio fallback ${PACKAGE_VERSION} using ${AGORAGENTIC_BASE}`);
+    }
+}
+
+function buildAcpInitializeResult() {
+    return {
+        protocolVersion: 1,
+        agentInfo: {
+            name: 'Agoragentic Agent OS',
+            version: PACKAGE_VERSION,
+            description:
+                'Agent OS integrations for deployed agents and swarms: execute-first routing, receipts, x402 edge calls, and Base USDC settlement.',
+            homepage: 'https://agoragentic.com',
         },
-        {
-            name: "find_and_invoke",
-            description: "Search for a capability matching your task and invoke it in one guided workflow.",
-            arguments: [
-                { name: "task", description: "Description of what you want to accomplish", required: true },
-                { name: "max_budget", description: "Maximum USDC budget for the invocation", required: false }
-            ]
+        agentCapabilities: {
+            tools: true,
+            streaming: false,
+            resources: false,
+            prompts: false,
+            loadSession: false,
+            promptCapabilities: {
+                image: false,
+            },
         },
-        {
-            name: "sell_capability",
-            description: "Guide for listing your own capability for sale on the Agoragentic marketplace.",
-            arguments: [
-                { name: "capability_name", description: "Name of the capability you want to sell", required: true },
-                { name: "price", description: "Price in USDC per invocation", required: false }
-            ]
-        }
-    ]
-}));
-
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    if (name === "quickstart") {
-        return {
-            description: "Get started with Agoragentic",
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `I want to get started with Agoragentic. Please:\n1. Register me as an agent named "${args?.agent_name || 'my-agent'}"\n2. Search for capabilities${args?.task ? ` related to: ${args.task}` : ''}\n3. Show me the top results and explain how to invoke one\n\nUse the agoragentic_register, agoragentic_search, and agoragentic_categories tools to help me.`
-                    }
-                }
-            ]
-        };
-    }
+        authMethods: [
+            {
+                type: 'env',
+                name: 'AGORAGENTIC_API_KEY',
+                configured: Boolean(API_KEY),
+                required: false,
+                instructions:
+                    'Optional for public discovery and x402 edge calls. Required for authenticated execute/match/status/receipt. Create one with POST /api/quickstart and intent=buyer|seller|both.',
+            },
+        ],
+    };
+}
 
-    if (name === "find_and_invoke") {
-        return {
-            description: "Find and invoke a capability",
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `I need to: ${args?.task || 'find a useful capability'}\n\nPlease:\n1. Search for matching capabilities${args?.max_budget ? ` under $${args.max_budget} USDC` : ''}\n2. Show me the best match with its price\n3. Invoke it if I confirm\n\nUse agoragentic_search and agoragentic_invoke tools.`
-                    }
-                }
-            ]
-        };
-    }
+function buildAcpResponse(id, result) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result,
+    };
+}
 
-    if (name === "sell_capability") {
-        return {
-            description: "List a capability for sale",
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `I want to sell a capability called "${args?.capability_name || 'my-service'}"${args?.price ? ` for $${args.price} USDC per call` : ''}.\n\nPlease walk me through:\n1. What information I need to provide\n2. The staking bond requirement ($5 USDC, refundable after 30 days)\n3. How to register and list it\n\nCheck agoragentic_categories for available categories first.`
-                    }
-                }
-            ]
-        };
-    }
+function buildAcpError(id, code, message, data) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: data ? { code, message, data } : { code, message },
+    };
+}
 
-    throw new Error(`Unknown prompt: ${name}`);
-});
+function writeAcpMessage(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+}
 
-// ─── 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.
+function buildAcpSessionId() {
+    return `sess_${crypto.randomBytes(12).toString('hex')}`;
+}
 
-const ACP_MODE = process.argv.includes("--acp");
+function extractAcpPromptText(content) {
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content)) return '';
+    return content
+        .map((part) => {
+            if (!part || typeof part !== 'object') return '';
+            if (part.type === 'text' && typeof part.text === 'string') return part.text;
+            return '';
+        })
+        .filter(Boolean)
+        .join('\n');
+}
 
-function createAcpServer() {
-    const readline = require("readline");
+function buildAcpPromptReply(promptText) {
+    const suffix = promptText ? ` Prompt received: ${promptText.slice(0, 240)}` : '';
+    return [
+        'Agoragentic ACP adapter is a tool bridge, not a code-editing chat agent.',
+        'Use tools/list, then tools/call with agoragentic_execute, agoragentic_match, agoragentic_quote, agoragentic_receipt, or stable x402 service tools.',
+        suffix,
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
 
+async function runAcpAdapter() {
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout,
+        crlfDelay: Infinity,
         terminal: false,
     });
 
-    function send(obj) {
-        process.stdout.write(JSON.stringify(obj) + "\n");
-    }
+    let remoteSession = null;
+    const acpSessions = new Map();
 
-    function sendResult(id, result) {
-        send({ jsonrpc: "2.0", id, result });
+    async function getRemoteSession() {
+        if (!remoteSession) {
+            remoteSession = await connectRemoteClient();
+        }
+        return remoteSession;
     }
 
-    function sendError(id, code, message, data) {
-        send({ jsonrpc: "2.0", id, error: { code, message, ...(data ? { data } : {}) } });
+    async function shutdownRemote() {
+        if (!remoteSession) return;
+        try {
+            await remoteSession.transport.terminateSession();
+        } catch {
+            // Ignore session teardown failures during local shutdown.
+        }
+        try {
+            await remoteSession.transport.close();
+        } catch {
+            // Ignore transport close failures during local shutdown.
+        }
+        remoteSession = null;
     }
 
-    // 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.",
-                    },
-                ],
-        });
-    }
+    process.on('SIGINT', () => {
+        void shutdownRemote().finally(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+        void shutdownRemote().finally(() => process.exit(0));
+    });
+
+    console.error(`[agoragentic-mcp] ACP adapter ${PACKAGE_VERSION} ready`);
+
+    for await (const line of rl) {
+        if (!line.trim()) continue;
 
-    rl.on("line", async (line) => {
-        let msg;
+        let request;
         try {
-            msg = JSON.parse(line.trim());
-        } catch {
-            sendError(null, -32700, "Parse error");
-            return;
+            request = JSON.parse(line);
+        } catch (error) {
+            writeAcpMessage(buildAcpError(null, -32700, 'Invalid JSON-RPC payload'));
+            continue;
         }
 
-        if (msg.jsonrpc !== "2.0") {
-            sendError(msg.id || null, -32600, "Invalid JSON-RPC version");
-            return;
+        const hasId = Object.prototype.hasOwnProperty.call(request, 'id');
+        const id = hasId ? request.id : null;
+
+        function writeResponse(message) {
+            if (hasId) writeAcpMessage(message);
         }
 
         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;
+            if (request.method === 'initialize') {
+                writeResponse(buildAcpResponse(id, buildAcpInitializeResult()));
+            } else if (request.method === 'session/new') {
+                const sessionId = buildAcpSessionId();
+                acpSessions.set(sessionId, {
+                    cwd: request.params?.cwd || process.cwd(),
+                    createdAt: new Date().toISOString(),
+                    cancelled: false,
+                });
+                writeResponse(buildAcpResponse(id, { sessionId }));
+            } else if (request.method === 'session/prompt') {
+                const sessionId = request.params?.sessionId;
+                if (!sessionId || !acpSessions.has(sessionId)) {
+                    writeResponse(buildAcpError(id, -32602, 'Unknown or missing ACP sessionId'));
+                    continue;
                 }
 
-                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);
+                const session = acpSessions.get(sessionId);
+                session.cancelled = false;
+                const promptText = extractAcpPromptText(request.params?.content);
+                const reply = buildAcpPromptReply(promptText);
+
+                writeAcpMessage({
+                    jsonrpc: '2.0',
+                    method: 'session/update',
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: 'agent_message_chunk',
+                            content: {
+                                type: 'text',
+                                text: reply,
+                            },
+                        },
+                    },
+                });
+                writeResponse(buildAcpResponse(id, { stopReason: session.cancelled ? 'cancelled' : 'end_turn' }));
+            } else if (request.method === 'session/cancel') {
+                const sessionId = request.params?.sessionId;
+                if (sessionId && acpSessions.has(sessionId)) {
+                    acpSessions.get(sessionId).cancelled = true;
+                }
+                writeResponse(buildAcpResponse(id, { ok: true }));
+            } else if (request.method === 'tools/list') {
+                writeResponse(buildAcpResponse(id, { tools: ACP_TOOLS }));
+            } else if (request.method === 'tools/call') {
+                const { client } = await getRemoteSession();
+                const result = await client.callTool(request.params || {});
+                writeResponse(buildAcpResponse(id, result));
+            } else if (request.method === 'shutdown') {
+                await shutdownRemote();
+                writeResponse(buildAcpResponse(id, { ok: true }));
             } else {
-                sendError(msg.id, -32603, err.message || "Internal error");
+                writeResponse(
+                    buildAcpError(id, -32601, 'Unsupported ACP method', {
+                        supported_methods: [
+                            'initialize',
+                            'session/new',
+                            'session/prompt',
+                            'session/cancel',
+                            'tools/list',
+                            'tools/call',
+                            'shutdown',
+                        ],
+                    })
+                );
             }
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeResponse(buildAcpError(id, -32000, message));
         }
-    });
-
-    rl.on("close", () => process.exit(0));
-
-    console.error("Agoragentic ACP Agent v2.0 running on stdio (ACP mode)");
-}
-
-// ─── Start ───────────────────────────────────────────────
-
-async function main() {
-    if (ACP_MODE) {
-        createAcpServer();
-    } else {
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        console.error("Agoragentic MCP Server v2.0 running on stdio");
     }
+
+    await shutdownRemote();
 }
 
-main().catch(console.error);
+const entrypoint = ACP_MODE ? runAcpAdapter : runMcpRelay;
 
+entrypoint().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    console.error(`[agoragentic-mcp] fatal: ${message}`);
+    process.exit(1);
+});