plugin-x402-endpoints 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,150 +1,11 @@
-import { Provider, Action, Plugin } from '@elizaos/core';
-
-/**
- * Types describing the x402 catalogue consumed by the plugin.
- *
- * The catalogue (src/catalog.json) is the single source of truth: one entry per
- * deployed x402 endpoint. The plugin turns each entry into an ElizaOS Action and
- * lists them in a Provider, so an Eliza agent discovers and calls them natively.
- */
-interface CatalogInputSchema {
-    type: "object";
-    properties: Record<string, {
-        type: string;
-        description?: string;
-        pattern?: string;
-    }>;
-    required?: string[];
-}
-interface CatalogEndpoint {
-    /** Short tool id, e.g. "gleif_lei". */
-    tool: string;
-    /** ElizaOS action name, e.g. "X402_GLEIF_LEI". */
-    action: string;
-    /** API path, e.g. "/gleif/lei". */
-    path: string;
-    /** HTTP method (all GET today). */
-    method: string;
-    /** Human price label, e.g. "$0.01". */
-    price: string;
-    /** Authority-rich semantic description (drives discovery). */
-    description: string;
-    /** Dense usage prompt for LLM agents. */
-    llm_usage_prompt?: string;
-    /** Semantic tags. */
-    tags?: string[];
-    /** JSON Schema for the query parameters. */
-    inputSchema: CatalogInputSchema;
-    /** A real example response (helps the agent before paying). */
-    outputExample?: unknown;
-    /** Payment metadata (mirrors the global values). */
-    payTo?: string;
-    network?: string;
-    asset?: string;
-}
-interface Catalog {
-    name: string;
-    baseUrl: string;
-    network: string;
-    asset: string;
-    payTo: string;
-    facilitator: string;
-    endpoints: CatalogEndpoint[];
-}
-/** Result of a paid (or discovery) call to an endpoint. */
-type CallResult = {
-    kind: "data";
-    status: number;
-    data: unknown;
-} | {
-    kind: "payment_required";
-    terms: PaymentTerms;
-} | {
-    kind: "error";
-    status?: number;
-    message: string;
-    detail?: string;
-};
-interface PaymentTerms {
-    x402PaymentRequired: true;
-    tool: string;
-    resource: string;
-    price: string;
-    network: string;
-    asset?: string;
-    payTo?: string;
-    scheme: string;
-    maxTimeoutSeconds: number;
-    howToPay: string;
-    exampleOutput?: unknown;
-}
-
-/**
- * Loads and exposes the bundled x402 catalogue.
- *
- * catalog.json is embedded at build time (resolveJsonModule), so the published
- * plugin is self-contained and never diverges from the deployed catalogue it was
- * built from. Runtime settings can still override baseUrl/network if needed.
- */
-
-declare const catalog: Catalog;
-declare const endpoints: CatalogEndpoint[];
-declare const ENDPOINT_COUNT: number;
-
-/**
- * Provider that injects the x402 catalogue into the agent's context, so the agent
- * is aware of every paid tool it can call (drives tool selection / discovery).
- */
-
-declare const x402CatalogProvider: Provider;
-
-/**
- * Builds one ElizaOS Action per catalogue endpoint.
- *
- * Each action:
- *  - is named after the endpoint (e.g. X402_GLEIF_LEI),
- *  - carries a dense, discovery-friendly description (+ price + usage prompt),
- *  - extracts call parameters from explicit options, structured content, or the
- *    natural-language message (via the runtime model), validating required fields,
- *  - calls the endpoint (auto-pay or discovery) and reports the result via callback.
- */
-
-declare function buildActions(): Action[];
-
-/**
- * x402 HTTP client for the plugin.
- *
- * Two modes, mirroring the MCP server:
- *  - auto-pay  : a funded Base buyer key is configured -> pays the 402 and returns live data.
- *  - discovery : no key (or auto-pay disabled) -> returns the exact payment terms.
- *
- * x402-fetch + viem are imported lazily so an agent that never auto-pays does not
- * need a signer at runtime.
- */
-
-interface ClientConfig {
-    baseUrl: string;
-    network: string;
-    buyerPrivateKey?: string;
-    autoPay: boolean;
-}
-type GetSetting = (key: string) => unknown;
-/** Resolve runtime config from agent settings, falling back to the bundled catalogue. */
-declare function resolveConfig(getSetting: GetSetting): ClientConfig;
-/** Call one endpoint. Auto-pays when configured and funded; otherwise returns terms. */
-declare function callEndpoint(ep: CatalogEndpoint, params: Record<string, unknown>, cfg: ClientConfig): Promise<CallResult>;
-
-/**
- * @x402-endpoints/plugin-elizaos
- *
- * ElizaOS plugin exposing the x402-endpoints catalogue (28 paid data endpoints:
- * official EU/global registries + crypto pre-trade data) as native Eliza actions,
- * billed per call via the x402 protocol (USDC on Base mainnet).
- *
- * Configure X402_BUYER_PRIVATE_KEY (a funded Base wallet) to auto-pay and receive
- * live data; otherwise actions return the exact payment terms (discovery).
- */
-
-declare const x402Plugin: Plugin;
-
-export { type CallResult, type Catalog, type CatalogEndpoint, type CatalogInputSchema, ENDPOINT_COUNT, type PaymentTerms, buildActions, callEndpoint, catalog, x402Plugin as default, endpoints, resolveConfig, x402CatalogProvider, x402Plugin };
+// Type stubs for plugin-x402-endpoints (runtime is JS; loaded by the ElizaOS host).
+declare const x402Plugin: any;
+export default x402Plugin;
+export { x402Plugin };
+export declare const catalog: any;
+export declare const endpoints: any[];
+export declare const ENDPOINT_COUNT: number;
+export declare const x402CatalogProvider: any;
+export declare function buildActions(...args: any[]): any[];
+export declare function callEndpoint(...args: any[]): any;
+export declare function resolveConfig(...args: any[]): any;

package/dist/index.js

@@ -1935,6 +1935,190 @@ var catalog_default = {
           }
         }
       }
+    },
+    {
+      tool: "agent_due_diligence",
+      action: "X402_AGENT_DUE_DILIGENCE",
+      path: "/agent/due-diligence",
+      method: "POST",
+      price: "$0.50",
+      description: "Vet any company, crypto project, counterparty or domain before engaging: one call composes a risk DOSSIER \u2014 synthesis + detected signals + sources + 0-100 risk score + GO/CAUTION/STOP verdict + recommendation + a signed, offline-verifiable receipt. Is this entity a scam, fraud, sanctioned, or safe to deal with? Replaces 3-4 manual web searches plus the synthesis an agent would have to do itself, composed from live public web signals. Counterparty / vendor / project due-diligence for agents. Price: $0.50 per call (x402 payment, USDC on Base mainnet).",
+      llm_usage_prompt: "Composed risk dossier on any entity/project/counterparty/domain: summary + signals + sources + 0-100 score + GO/CAUTION/STOP verdict + signed receipt. One call replaces 3-4 lookups. Input: target.",
+      tags: [
+        "due-diligence",
+        "kyb",
+        "counterparty-risk",
+        "risk-dossier",
+        "agent-decision"
+      ],
+      inputSchema: {
+        type: "object",
+        properties: {
+          target: {
+            type: "string",
+            description: "Entity / project / counterparty / domain to vet, e.g. 'Acme DeFi Labs'"
+          },
+          target_type: {
+            type: "string",
+            description: "Optional: entity | project | counterparty | domain | wallet"
+          },
+          context: {
+            type: "string",
+            description: "Optional: why you're engaging / what you're about to do"
+          }
+        },
+        required: [
+          "target"
+        ]
+      }
+    },
+    {
+      tool: "agent_analysis_report",
+      action: "X402_AGENT_ANALYSIS_REPORT",
+      path: "/agent/analysis-report",
+      method: "POST",
+      price: "$0.25",
+      description: "Structured analysis report on any URL, company, product or subject in one call: positioning + strengths + risks + opportunities + 0-100 actionable score + STRONG/MODERATE/WEAK rating + recommendation + provenance + a signed receipt. A fixed-schema research report an agent can consume without re-parsing, composed from live public web signals. Competitive / investment / partnership analysis for agents. Price: $0.25 per call (x402 payment, USDC on Base mainnet).",
+      llm_usage_prompt: "Fixed-schema analysis report on a URL/company/subject: positioning + strengths + risks + opportunities + 0-100 score + STRONG/MODERATE/WEAK + signed receipt. Input: input (+ optional focus).",
+      tags: [
+        "analysis-report",
+        "market-analysis",
+        "competitive",
+        "research",
+        "agent-decision"
+      ],
+      inputSchema: {
+        type: "object",
+        properties: {
+          input: {
+            type: "string",
+            description: "URL, company, product or subject, e.g. 'stripe.com'"
+          },
+          focus: {
+            type: "string",
+            description: "Optional: investment | competitive | partnership | security | general"
+          }
+        },
+        required: [
+          "input"
+        ]
+      }
+    },
+    {
+      tool: "agent_clearance",
+      action: "X402_AGENT_CLEARANCE",
+      path: "/agent/clearance",
+      method: "POST",
+      price: "$0.25",
+      description: "Safety preflight before an agent runs a DESTRUCTIVE, costly or IRREVERSIBLE action (delete, deploy, transfer funds, publish, overwrite): risk assessment + reversibility check + timing + CLEAR/LIMIT/REVIEW/BLOCK verdict + a cryptographically SIGNED ClearancePacket (decision, approved amount, policy version, evidence hash, expiry, rationale) the agent keeps as proof of authorization. Should I run this action, or stop and ask a human? Stops a mistake far costlier than the call price. Agent action guardrail / clearance / human-in-the-loop gate. Price: $0.25 per call (x402 payment, USDC on Base mainnet).",
+      llm_usage_prompt: "Preflight clearance before a destructive/costly/irreversible agent action: risk + reversibility + timing + CLEAR/LIMIT/REVIEW/BLOCK + a signed Ed25519 ClearancePacket. Input: action (+ action_type, amount_usd).",
+      tags: [
+        "preflight",
+        "action-clearance",
+        "reversibility",
+        "agent-safety",
+        "guardrail"
+      ],
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            description: "Action about to run, e.g. 'delete the production users table'"
+          },
+          action_type: {
+            type: "string",
+            description: "Optional: delete|deploy|send|spend|transfer|publish|email|overwrite|approve|rotate|shutdown|other"
+          },
+          amount_usd: {
+            type: "number",
+            description: "Monetary stake in USD if applicable, e.g. 250"
+          },
+          reversible: {
+            type: "boolean",
+            description: "Optional caller hint: is the action reversible?"
+          },
+          target: {
+            type: "string",
+            description: "Optional target (table, address, repo, recipient)"
+          },
+          context: {
+            type: "string",
+            description: "Optional extra context (environment, prior approval)"
+          }
+        },
+        required: [
+          "action"
+        ]
+      }
+    },
+    {
+      tool: "agent_output_qa",
+      action: "X402_AGENT_OUTPUT_QA",
+      path: "/agent/output-qa",
+      method: "POST",
+      price: "$0.10",
+      description: "Review and improve an agent's outbound text (email, social post, customer reply) before sending: a multi-criteria scorecard (clarity, spam-safety, tone, length, personalization, CTA, compliance \u2014 each 0-100) + poor/fair/good/excellent rating + top suggestions + a ready-to-send IMPROVED REWRITE. Will this message land or get flagged as spam? One call scores and rewrites. Output review / spam check / copy QA for agents. Price: $0.10 per call (x402 payment, USDC on Base mainnet).",
+      llm_usage_prompt: "Score an agent's outbound text on 7 criteria (clarity, spam-safety, tone, length, personalization, CTA, compliance) + rating + suggestions + improved rewrite. Input: output (+ format, goal).",
+      tags: [
+        "output-qa",
+        "email-review",
+        "content-scoring",
+        "rewrite",
+        "agent-decision"
+      ],
+      inputSchema: {
+        type: "object",
+        properties: {
+          output: {
+            type: "string",
+            description: "The agent's outbound text to review (email, post, reply)"
+          },
+          format: {
+            type: "string",
+            description: "Optional: email | social_post | customer_reply | other"
+          },
+          goal: {
+            type: "string",
+            description: "Optional intended goal, e.g. 'book a demo'"
+          }
+        },
+        required: [
+          "output"
+        ]
+      }
+    },
+    {
+      tool: "agent_content_scan",
+      action: "X402_AGENT_CONTENT_SCAN",
+      path: "/agent/content-scan",
+      method: "POST",
+      price: "$0.10",
+      description: "Scan any external content before an agent INGESTS it (SKILL.md, web page, user input, tool output) for prompt-injection, data exfiltration, dangerous code execution, hidden/invisible unicode and instruction overrides: 0-100 risk score + SAFE/WARN/BLOCK verdict + structured findings with matched evidence. Is it safe to feed this content to my agent? A fast, cheap, deterministic, high-volume pre-ingest firewall. Prompt-injection / skill-audit / untrusted-content security check for agents. Price: $0.10 per call (x402 payment, USDC on Base mainnet).",
+      llm_usage_prompt: "Deterministic pre-ingest scan for prompt-injection, exfiltration, dangerous exec, hidden unicode and instruction overrides: 0-100 risk score + SAFE/WARN/BLOCK + structured findings. Input: content.",
+      tags: [
+        "content-scan",
+        "prompt-injection",
+        "exfiltration",
+        "agent-security",
+        "safe-ingest"
+      ],
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "Raw content to scan before ingestion (SKILL.md, web page, user input, tool output)"
+          },
+          source_type: {
+            type: "string",
+            description: "Optional: skill | webpage | user_input | tool_output | document"
+          }
+        },
+        required: [
+          "content"
+        ]
+      }
     }
   ]
 };
@@ -2034,12 +2218,15 @@ async function readBody(resp) {
   }
 }
 async function callEndpoint(ep, params, cfg) {
-  const url = buildUrl(cfg.baseUrl, ep.path, params);
-  const headers = { accept: "application/json" };
+  const method = (ep.method || "GET").toUpperCase();
+  const isPost = method === "POST";
+  const url = isPost ? `${cfg.baseUrl}${ep.path}` : buildUrl(cfg.baseUrl, ep.path, params);
+  const headers = isPost ? { accept: "application/json", "content-type": "application/json" } : { accept: "application/json" };
+  const reqInit = isPost ? { method, headers, body: JSON.stringify(params || {}) } : { method, headers };
   const paidFetch = await getPaidFetch(cfg).catch(() => null);
   if (paidFetch) {
     try {
-      const resp2 = await paidFetch(url, { method: "GET", headers });
+      const resp2 = await paidFetch(url, reqInit);
       const body2 = await readBody(resp2);
       if (resp2.status === 200) return { kind: "data", status: 200, data: body2 };
       if (resp2.status === 402) {
@@ -2057,7 +2244,7 @@ async function callEndpoint(ep, params, cfg) {
   }
   let resp;
   try {
-    resp = await fetch(url, { method: "GET", headers });
+    resp = await fetch(url, reqInit);
   } catch (err) {
     return { kind: "error", message: "request failed", detail: `${err?.name}: ${err?.message}` };
   }