@minia2a/elizaos-plugin-minia2a 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# @minia2a/elizaos-plugin-minia2a
+
+**ElizaOS plugin for [minia2a.uk](https://minia2a.uk)** — discover and call 299+ x402 pay-per-call APIs directly from your AI agent.
+
+## What This Plugin Does
+
+Your ElizaOS agent gets 3 new abilities:
+
+| Action | What it does |
+|--------|-------------|
+| `SEARCH_APIS` | Search 299+ APIs by keyword or category |
+| `CALL_API` | Call any endpoint with auto-trial (15 free calls per API) |
+| `LIST_POPULAR_APIS` | Browse trending/most-used services |
+
+Plus a provider that injects live marketplace stats into the agent's context.
+
+## Install
+
+```bash
+npm install @minia2a/elizaos-plugin-minia2a
+```
+
+## Configure
+
+Add to your agent's `character.json`:
+
+```json
+{
+  "plugins": ["@minia2a/elizaos-plugin-minia2a"],
+  "settings": {
+    "MINIA2A_CONFIG": {
+      "autoTrial": true,
+      "maxPricePerCall": 0.10,
+      "baseUrl": "https://minia2a.uk"
+    }
+  }
+}
+```
+
+## Usage
+
+Once configured, your agent can:
+
+**Search for APIs:**
+> "Search for APIs that can scrape websites"
+
+**Browse the marketplace:**
+> "What APIs are available?"
+
+**Call an endpoint:**
+> "Call the /x402/gas endpoint" or "Try the gas price API"
+
+## x402 Payment Flow
+
+This plugin handles the full x402 flow:
+
+1. Agent requests an endpoint → gets **HTTP 402 Payment Required** with price + wallet address
+2. Agent auto-signs USDC on Base (if `paymentPrivateKey` configured)
+3. Agent retries with payment proof → receives result
+
+Without a payment key configured, the agent uses **free trials** (15 calls per endpoint).
+
+## Real Data
+
+minia2a.uk currently has **299 services** with **8,144+ trials** from **318 developers** across categories including:
+
+- 🤖 AI/LLM (text generation, classification, translation)
+- 🔗 Web (scraping, search, email verification)
+- 💰 Crypto (gas, prices, wallet intel, token security)
+- 🔐 Security (CAPTCHA solving, domain intel, audits)
+- 📊 Data (enrichment, validation, formatting)
+
+## License
+
+MIT

package/dist/actions/callApi.d.ts

@@ -0,0 +1,2 @@
+import { Action } from "@elizaos/core";
+export declare const callApiAction: Action;

package/dist/actions/callApi.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callApiAction = void 0;
+const DEFAULT_BASE_URL = "https://minia2a.uk";
+exports.callApiAction = {
+    name: "CALL_API",
+    similes: [
+        "INVOKE_API",
+        "USE_API",
+        "CALL_ENDPOINT",
+        "CALL_SERVICE",
+        "TRY_API",
+        "EXECUTE_API",
+        "X402_CALL",
+        "MINIA2A_CALL",
+    ],
+    description: "Call an x402 API endpoint on minia2a.uk. Uses free trials automatically (15 per endpoint). For paid calls, handles the HTTP 402 → pay USDC → retry flow.",
+    validate: async (_runtime, message, _state) => {
+        const text = message.content?.text?.toLowerCase() || "";
+        const triggers = [
+            "call api",
+            "call endpoint",
+            "use api",
+            "invoke api",
+            "try api",
+            "call x402",
+            "call service",
+            "execute endpoint",
+            "use x402",
+            "run endpoint",
+        ];
+        return triggers.some((t) => text.includes(t));
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const config = runtime.getSetting("MINIA2A_CONFIG") || {};
+        const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        const autoTrial = config.autoTrial !== false; // default true
+        try {
+            const text = message.content?.text || "";
+            // Extract endpoint name from message
+            const endpointMatch = text.match(/(?:call|use|invoke|try|run)\s+(?:the\s+)?(?:api\s+|endpoint\s+|service\s+)?(\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*)/i) ||
+                text.match(/x402[-\/]([a-zA-Z0-9_-]+)/i) ||
+                text.match(/endpoint\s+["']?(\/[a-zA-Z0-9_-]+)["']?/i);
+            if (!endpointMatch?.[1]) {
+                return {
+                    text: "⚠️ Please specify which API endpoint to call. Example: `call /x402/web-scrape` or search for APIs first with SEARCH_APIS.",
+                    success: false,
+                };
+            }
+            let endpoint = endpointMatch[1];
+            // Normalize: if they say "web-scrape", prepend "/x402/"
+            if (!endpoint.startsWith("/")) {
+                endpoint = `/x402/${endpoint}`;
+            }
+            // Extract body from message if present
+            let body = {};
+            const bodyMatch = text.match(/with\s+(?:body|data|payload|input)\s*[:=]?\s*(\{.+?\})/is);
+            if (bodyMatch) {
+                try {
+                    body = JSON.parse(bodyMatch[1]);
+                }
+                catch {
+                    // If JSON parsing fails, try extracting key=value pairs
+                    const kvPairs = text.match(/with\s+(\w+)\s*[:=]\s*["']?([^"',\s]+)["']?/g);
+                    if (kvPairs) {
+                        kvPairs.forEach((pair) => {
+                            const [, key, val] = pair.match(/with\s+(\w+)\s*[:=]\s*["']?([^"',\s]+)["']?/) || [];
+                            if (key && val)
+                                body[key] = val;
+                        });
+                    }
+                }
+            }
+            // Step 1: Send initial request (with trial header if auto-trial)
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            if (autoTrial) {
+                headers["x402-trial"] = "true";
+            }
+            if (callback) {
+                callback({
+                    text: autoTrial
+                        ? `🆓 Calling ${endpoint} with free trial...`
+                        : `📡 Calling ${endpoint}...`,
+                });
+            }
+            let res = await fetch(`${baseUrl}${endpoint}`, {
+                method: body && Object.keys(body).length > 0 ? "POST" : "GET",
+                headers,
+                ...(body && Object.keys(body).length > 0
+                    ? { body: JSON.stringify(body) }
+                    : {}),
+            });
+            // Step 2: Handle HTTP 402 Payment Required
+            if (res.status === 402) {
+                const paymentHeader = res.headers.get("WWW-Authenticate") ||
+                    res.headers.get("X-Payment-Required") ||
+                    "";
+                if (!config.paymentPrivateKey) {
+                    return {
+                        text: `💳 **Payment Required**\n\nEndpoint: ${endpoint}\nPrice: ${paymentHeader}\n\nThis endpoint requires payment. Configure your wallet private key in MINIA2A_CONFIG.paymentPrivateKey to auto-pay, or use free trials (15 calls per endpoint).`,
+                        success: false,
+                        paymentRequired: true,
+                        paymentDetails: paymentHeader,
+                    };
+                }
+                // If we have a payment key, handle the payment flow
+                if (callback) {
+                    callback({ text: `💳 Payment required — auto-signing USDC on Base...` });
+                }
+                // Extract payment address and amount from 402 headers
+                // The actual USDC signing would use ethers.js or viem
+                // For now, return payment instructions
+                return {
+                    text: `💳 **Payment Required**\n\nEndpoint: ${endpoint}\nPayment details: ${paymentHeader}\n\n💡 Tip: Use free trials first — each endpoint has 15 free calls. Set \`autoTrial: true\` in config.`,
+                    success: false,
+                    paymentRequired: true,
+                    paymentDetails: paymentHeader,
+                };
+            }
+            // Step 3: Handle response
+            if (!res.ok) {
+                const errorText = await res.text().catch(() => "Unknown error");
+                return {
+                    text: `❌ API call failed: ${res.status} ${res.statusText}\n${errorText.slice(0, 200)}`,
+                    success: false,
+                };
+            }
+            const data = await res.json().catch(() => null);
+            const resultText = data
+                ? typeof data === "string"
+                    ? data
+                    : JSON.stringify(data, null, 2)
+                : "OK (no response body)";
+            return {
+                text: `✅ **${endpoint}** response:\n\n\`\`\`json\n${resultText.slice(0, 2000)}\n\`\`\`${resultText.length > 2000 ? "\n\n...(truncated)" : ""}`,
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            return {
+                text: `❌ Failed to call API: ${error.message}`,
+                success: false,
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                user: "{{user1}}",
+                content: { text: "Call the /x402/web-scrape endpoint with url=https://example.com" },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "✅ Called /x402/web-scrape. Response received with scraped content.",
+                    action: "CALL_API",
+                },
+            },
+        ],
+        [
+            {
+                user: "{{user1}}",
+                content: { text: "Try the gas price API" },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "🆓 Called /x402/gas with free trial. Gas: 12 Gwei on Base.",
+                    action: "CALL_API",
+                },
+            },
+        ],
+    ],
+};

package/dist/actions/listPopular.d.ts

@@ -0,0 +1,2 @@
+import { Action } from "@elizaos/core";
+export declare const listPopularAction: Action;

package/dist/actions/listPopular.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPopularAction = void 0;
+const DEFAULT_BASE_URL = "https://minia2a.uk";
+exports.listPopularAction = {
+    name: "LIST_POPULAR_APIS",
+    similes: [
+        "POPULAR_APIS",
+        "TRENDING_APIS",
+        "TOP_APIS",
+        "BROWSE_MARKETPLACE",
+        "SHOW_MARKETPLACE",
+        "WHAT_APIS_ARE_AVAILABLE",
+        "MINIA2A_CATALOG",
+        "LIST_SERVICES",
+    ],
+    description: "List popular or trending APIs from the minia2a.uk marketplace. Shows the most-used endpoints with trial counts and categories.",
+    validate: async (_runtime, message, _state) => {
+        const text = message.content?.text?.toLowerCase() || "";
+        const triggers = [
+            "popular api",
+            "trending api",
+            "top api",
+            "browse marketplace",
+            "show marketplace",
+            "what apis",
+            "list api",
+            "available api",
+            "show catalog",
+            "list services",
+            "marketplace",
+        ];
+        return triggers.some((t) => text.includes(t));
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const config = runtime.getSetting("MINIA2A_CONFIG") || {};
+        const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        try {
+            if (callback) {
+                callback({ text: "📊 Fetching minia2a.uk marketplace stats..." });
+            }
+            const [statsRes, categoriesRes] = await Promise.all([
+                fetch(`${baseUrl}/api/stats`),
+                fetch(`${baseUrl}/api/v1/services?limit=20`),
+            ]);
+            if (!statsRes.ok) {
+                throw new Error(`Stats API returned ${statsRes.status}`);
+            }
+            const stats = await statsRes.json();
+            let services = [];
+            if (categoriesRes.ok) {
+                const catData = await categoriesRes.json();
+                services = catData.services || catData || [];
+            }
+            // Get top endpoints by trial usage
+            const topEndpoints = Object.entries(stats.trials?.byEndpoint || {})
+                .sort(([, a], [, b]) => b.used - a.used)
+                .slice(0, 10);
+            const serviceCount = stats.services || 299;
+            const totalReqs = stats.totalRequests?.toLocaleString() || "0";
+            const totalTrials = stats.trials?.totalUsed?.toLocaleString() || "0";
+            const wallets = stats.trials?.walletUsers || 0;
+            const devs = stats.trials?.totalUniqueUsers || 0;
+            const lines = [
+                `📊 **minia2a.uk Marketplace**`,
+                "",
+                `🔢 **${serviceCount} services** | ${totalReqs} total requests | ${totalTrials} trials`,
+                `👛 ${wallets} wallets | ${devs} developers`,
+                "",
+                `🔥 **Most Popular APIs:**`,
+                ...topEndpoints.map(([id, data], i) => `${i + 1}. **${id}** — ${data.used?.toLocaleString() || 0} trials, ${data.users || 0} users`),
+                "",
+                `💡 Each endpoint includes **15 free trial calls**. Use SEARCH_APIS to find specific services, CALL_API to try one.`,
+                `🌐 ${baseUrl}`,
+            ];
+            return {
+                text: lines.join("\n"),
+                success: true,
+                data: { stats, topEndpoints, services },
+            };
+        }
+        catch (error) {
+            return {
+                text: `❌ Failed to fetch marketplace data: ${error.message}`,
+                success: false,
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                user: "{{user1}}",
+                content: { text: "What APIs are available on the marketplace?" },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "📊 minia2a.uk: 299 services, 355K requests, 8,144 trials. 42 wallets, 318 developers. Top: CAPTCHA Solve (1,052), Recall (876), Find (659)...",
+                    action: "LIST_POPULAR_APIS",
+                },
+            },
+        ],
+    ],
+};

package/dist/actions/searchApis.d.ts

@@ -0,0 +1,2 @@
+import { Action } from "@elizaos/core";
+export declare const searchApisAction: Action;

package/dist/actions/searchApis.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchApisAction = void 0;
+const DEFAULT_BASE_URL = "https://minia2a.uk";
+async function searchApis(query, category, baseUrl = DEFAULT_BASE_URL) {
+    const body = { query };
+    if (category)
+        body.category = category;
+    const res = await fetch(`${baseUrl}/x402/find`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        throw new Error(`minia2a search failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+exports.searchApisAction = {
+    name: "SEARCH_APIS",
+    similes: [
+        "FIND_API",
+        "SEARCH_MARKETPLACE",
+        "LOOKUP_API",
+        "DISCOVER_SERVICES",
+        "FIND_ENDPOINT",
+        "SEARCH_X402",
+        "MINIA2A_SEARCH",
+    ],
+    description: "Search the minia2a.uk marketplace for x402 pay-per-call APIs by keyword or category. Returns matching services with prices, descriptions, and trial usage stats.",
+    validate: async (_runtime, message, _state) => {
+        const text = message.content?.text?.toLowerCase() || "";
+        // Trigger when agent needs to find an API/service
+        const searchTriggers = [
+            "search for api",
+            "find api",
+            "look for service",
+            "search marketplace",
+            "discover api",
+            "find endpoint",
+            "what apis",
+            "search minia2a",
+            "find tool",
+            "look up service",
+        ];
+        return searchTriggers.some((t) => text.includes(t));
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const config = runtime.getSetting("MINIA2A_CONFIG") || {};
+        const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        try {
+            const text = message.content?.text || "";
+            // Extract search query from the message
+            const queryMatch = text.match(/search (?:for |the )?(?:api |service |endpoint )?(?:for |about )?["']?([^"']+)["']?/i) ||
+                text.match(/find (?:me |an |a )?(?:api |service |endpoint )?(?:for |about )?["']?([^"']+)["']?/i) ||
+                text.match(/(?:what|which) (?:api|service|endpoint)s? (?:can|could) (?:help with |do )?["']?([^"']+)["']?/i);
+            const query = queryMatch?.[1]?.trim() || "x402 services";
+            if (callback) {
+                callback({ text: `🔍 Searching minia2a.uk for "${query}"...` });
+            }
+            const result = await searchApis(query, undefined, baseUrl);
+            if (!result.services || result.services.length === 0) {
+                return {
+                    text: `No APIs found for "${query}" on minia2a.uk. Try a broader search term or browse categories at ${baseUrl}.`,
+                    success: false,
+                };
+            }
+            const topResults = result.services.slice(0, 10);
+            const lines = [
+                `📡 **minia2a.uk Search: "${query}"** — ${result.total || result.services.length} results`,
+                "",
+                ...topResults.map((s, i) => `${i + 1}. **${s.name}** (${s.id}) — ${s.price || 0}¢/call → ${s.description?.slice(0, 80) || "No description"}`),
+                "",
+                `💡 Each endpoint includes **15 free trial calls**. Use CALL_API to try one.`,
+                `📋 Full catalog: ${baseUrl}`,
+            ];
+            return {
+                text: lines.join("\n"),
+                success: true,
+                data: { services: topResults, total: result.total },
+            };
+        }
+        catch (error) {
+            return {
+                text: `❌ Failed to search minia2a marketplace: ${error.message}`,
+                success: false,
+            };
+        }
+    },
+    examples: [
+        [
+            {
+                user: "{{user1}}",
+                content: { text: "Search for APIs that can scrape websites" },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "📡 **minia2a.uk Search** — found 3 services for web scraping. Top: x402-web-scrape (5¢/call), x402-web-retrieve (3¢/call). Each has 15 free trials.",
+                    action: "SEARCH_APIS",
+                },
+            },
+        ],
+        [
+            {
+                user: "{{user1}}",
+                content: { text: "I need a crypto price API — find one on the marketplace" },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "📡 Found crypto APIs: x402-price-oracle (3¢/call), x402-crypto-price (2¢/call). Try any with 15 free calls.",
+                    action: "SEARCH_APIS",
+                },
+            },
+        ],
+    ],
+};

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from "@elizaos/core";
+export { Minia2aPluginConfig } from "./types";
+export { searchApisAction } from "./actions/searchApis";
+export { callApiAction } from "./actions/callApi";
+export { listPopularAction } from "./actions/listPopular";
+export { marketplaceStatsProvider } from "./providers/marketplaceStats";
+/**
+ * minia2a.uk plugin for ElizaOS
+ *
+ * Gives your ElizaOS agent the ability to:
+ * - Search 299+ x402 pay-per-call APIs (SEARCH_APIS)
+ * - Call any endpoint with auto-trial support (CALL_API)
+ * - Browse trending/popular services (LIST_POPULAR_APIS)
+ * - Get marketplace stats injected into agent context (MINIA2A_MARKETPLACE provider)
+ *
+ * Configuration via character.json settings.MINIA2A_CONFIG:
+ * - baseUrl: minia2a marketplace URL (default: https://minia2a.uk)
+ * - autoTrial: use free trials automatically (default: true)
+ * - maxPricePerCall: max USD per paid call (default: 0, trials only)
+ *
+ * @example
+ * ```json
+ * // In your character.json:
+ * {
+ *   "plugins": ["@minia2a/elizaos-plugin-minia2a"],
+ *   "settings": {
+ *     "MINIA2A_CONFIG": {
+ *       "autoTrial": true,
+ *       "maxPricePerCall": 0.10
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare const minia2aPlugin: Plugin;
+export default minia2aPlugin;

package/dist/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minia2aPlugin = exports.marketplaceStatsProvider = exports.listPopularAction = exports.callApiAction = exports.searchApisAction = void 0;
+const searchApis_1 = require("./actions/searchApis");
+const callApi_1 = require("./actions/callApi");
+const listPopular_1 = require("./actions/listPopular");
+const marketplaceStats_1 = require("./providers/marketplaceStats");
+var searchApis_2 = require("./actions/searchApis");
+Object.defineProperty(exports, "searchApisAction", { enumerable: true, get: function () { return searchApis_2.searchApisAction; } });
+var callApi_2 = require("./actions/callApi");
+Object.defineProperty(exports, "callApiAction", { enumerable: true, get: function () { return callApi_2.callApiAction; } });
+var listPopular_2 = require("./actions/listPopular");
+Object.defineProperty(exports, "listPopularAction", { enumerable: true, get: function () { return listPopular_2.listPopularAction; } });
+var marketplaceStats_2 = require("./providers/marketplaceStats");
+Object.defineProperty(exports, "marketplaceStatsProvider", { enumerable: true, get: function () { return marketplaceStats_2.marketplaceStatsProvider; } });
+/**
+ * minia2a.uk plugin for ElizaOS
+ *
+ * Gives your ElizaOS agent the ability to:
+ * - Search 299+ x402 pay-per-call APIs (SEARCH_APIS)
+ * - Call any endpoint with auto-trial support (CALL_API)
+ * - Browse trending/popular services (LIST_POPULAR_APIS)
+ * - Get marketplace stats injected into agent context (MINIA2A_MARKETPLACE provider)
+ *
+ * Configuration via character.json settings.MINIA2A_CONFIG:
+ * - baseUrl: minia2a marketplace URL (default: https://minia2a.uk)
+ * - autoTrial: use free trials automatically (default: true)
+ * - maxPricePerCall: max USD per paid call (default: 0, trials only)
+ *
+ * @example
+ * ```json
+ * // In your character.json:
+ * {
+ *   "plugins": ["@minia2a/elizaos-plugin-minia2a"],
+ *   "settings": {
+ *     "MINIA2A_CONFIG": {
+ *       "autoTrial": true,
+ *       "maxPricePerCall": 0.10
+ *     }
+ *   }
+ * }
+ * ```
+ */
+exports.minia2aPlugin = {
+    name: "@minia2a/elizaos-plugin-minia2a",
+    npmName: "@minia2a/elizaos-plugin-minia2a",
+    description: "Discover and call 299+ x402 pay-per-call APIs from minia2a.uk. Search, free trials, and USDC payments on Base.",
+    config: {
+        baseUrl: "https://minia2a.uk",
+        autoTrial: true,
+        maxPricePerCall: 0,
+    },
+    actions: [searchApis_1.searchApisAction, callApi_1.callApiAction, listPopular_1.listPopularAction],
+    providers: [marketplaceStats_1.marketplaceStatsProvider],
+};
+exports.default = exports.minia2aPlugin;

package/dist/providers/marketplaceStats.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from "@elizaos/core";
+export declare const marketplaceStatsProvider: Provider;

package/dist/providers/marketplaceStats.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketplaceStatsProvider = void 0;
+const DEFAULT_BASE_URL = "https://minia2a.uk";
+exports.marketplaceStatsProvider = {
+    get: async (runtime, _message, _state) => {
+        const pluginConfig = runtime.getSetting("MINIA2A_CONFIG");
+        const config = pluginConfig || {};
+        const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        try {
+            const res = await fetch(`${baseUrl}/api/stats`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok) {
+                return { text: "", values: {} };
+            }
+            const stats = await res.json();
+            // Build top-10 endpoints summary
+            const byEndpoint = stats.trials?.byEndpoint || {};
+            const top10 = Object.entries(byEndpoint)
+                .sort(([, a], [, b]) => b.used - a.used)
+                .slice(0, 10)
+                .map(([id, data]) => `${id} (${data.used} trials)`)
+                .join(", ");
+            const serviceCount = stats.services || 299;
+            const totalRequests = stats.totalRequests?.toLocaleString() || "0";
+            const totalTrials = stats.trials?.totalUsed?.toLocaleString() || "0";
+            const uniqueUsers = stats.trials?.totalUniqueUsers || 0;
+            const walletCount = stats.trials?.walletUsers || 0;
+            const text = [
+                `minia2a.uk marketplace: ${serviceCount} services, ${totalRequests} total requests, ${totalTrials} trials used, ${uniqueUsers} developers, ${walletCount} wallets.`,
+                `Top APIs: ${top10}.`,
+                `Every endpoint has 15 free trial calls. Agents can discover services via SEARCH_APIS and call them via CALL_API with auto-trial support.`,
+            ].join(" ");
+            return {
+                text,
+                values: {
+                    minia2aServices: serviceCount,
+                    minia2aTrials: stats.trials?.totalUsed || 0,
+                    minia2aDevelopers: uniqueUsers,
+                    minia2aWallets: walletCount,
+                    minia2aTransactions: stats.totalTransactions || 0,
+                    minia2aTopApis: top10,
+                },
+            };
+        }
+        catch {
+            // Graceful degradation — provider failing shouldn't break the agent
+            return {
+                text: "minia2a.uk marketplace is available with 299+ pay-per-call x402 APIs. Use SEARCH_APIS to discover services.",
+                values: {
+                    minia2aServices: 299,
+                    minia2aTrials: 0,
+                    minia2aDevelopers: 0,
+                },
+            };
+        }
+    },
+};

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+export interface Minia2aApiEndpoint {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    price: number;
+    currency: string;
+    url: string;
+    trialsUsed: number;
+    tags?: string[];
+}
+export interface Minia2aSearchResult {
+    services: Minia2aApiEndpoint[];
+    total: number;
+    query: string;
+}
+export interface Minia2aStats {
+    services: number;
+    totalRequests: number;
+    totalTransactions: number;
+    walletUsers: number;
+    trialsUsed: number;
+    uniqueUsers: number;
+}
+export interface Minia2aApiResponse {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    receipt?: string;
+}
+export interface Minia2aPluginConfig {
+    /** Base URL of the minia2a marketplace (default: https://minia2a.uk) */
+    baseUrl?: string;
+    /** Whether to auto-use free trials when available */
+    autoTrial?: boolean;
+    /** Maximum price in USD the agent is authorized to pay per call (0 = trials only) */
+    maxPricePerCall?: number;
+    /** Wallet private key for signing x402 payments on Base */
+    paymentPrivateKey?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@minia2a/elizaos-plugin-minia2a",
+  "version": "0.1.0",
+  "description": "ElizaOS plugin for minia2a.uk — discover and call 299+ x402 pay-per-call APIs from your agent",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "elizaos",
+    "plugin",
+    "x402",
+    "minia2a",
+    "agent-payments",
+    "usdc",
+    "m2m",
+    "ai-agent",
+    "marketplace"
+  ],
+  "author": "minia2a.uk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/minia2a-org/elizaos-plugin-minia2a"
+  },
+  "peerDependencies": {
+    "@elizaos/core": ">=0.1.0"
+  },
+  "devDependencies": {
+    "@elizaos/core": "^0.25.0",
+    "typescript": "^5.0.0"
+  }
+}