@agentwonderland/mcp 0.1.1

package/dist/core/api-client.d.ts

@@ -0,0 +1,14 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+export declare function apiGet<T>(path: string): Promise<T>;
+export declare function apiPost<T>(path: string, body: unknown): Promise<T>;
+/**
+ * POST with payment support. Uses the configured payment method to
+ * auto-handle 402 → sign → retry for paid endpoints.
+ * Pass `payWith` to specify a method, or omit for auto-detection.
+ */
+export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string): Promise<T>;
+export declare function apiPut<T>(path: string, body: unknown): Promise<T>;

package/dist/core/api-client.js

@@ -0,0 +1,98 @@
+import { getApiUrl, getApiKey } from "./config.js";
+import { getPaymentFetch } from "./payments.js";
+// ── Error class ────────────────────────────────────────────────────
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "ApiError";
+    }
+}
+// ── Internal helpers ───────────────────────────────────────────────
+function buildHeaders() {
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    };
+    const apiKey = getApiKey();
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    return headers;
+}
+async function handleResponse(response) {
+    let body;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        body = await response.json();
+    }
+    else {
+        body = await response.text();
+    }
+    if (!response.ok) {
+        const bodyObj = body && typeof body === "object" ? body : null;
+        const message = bodyObj?.error
+            ? String(bodyObj.error)
+            : bodyObj?.message
+                ? String(bodyObj.message)
+                : typeof body === "string"
+                    ? body
+                    : `Request failed with status ${response.status}`;
+        throw new ApiError(response.status, message, body);
+    }
+    return body;
+}
+// ── Public API ─────────────────────────────────────────────────────
+export async function apiGet(path) {
+    const url = `${getApiUrl()}${path}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(),
+    });
+    return handleResponse(response);
+}
+export async function apiPost(path, body) {
+    const url = `${getApiUrl()}${path}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(body),
+    });
+    return handleResponse(response);
+}
+/**
+ * POST with payment support. Uses the configured payment method to
+ * auto-handle 402 → sign → retry for paid endpoints.
+ * Pass `payWith` to specify a method, or omit for auto-detection.
+ */
+export async function apiPostWithPayment(path, body, payWith) {
+    const url = `${getApiUrl()}${path}`;
+    const paymentFetch = await getPaymentFetch(payWith);
+    const response = await paymentFetch(url, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(body),
+    });
+    const result = await handleResponse(response);
+    // mppx may strip extra fields from the response body during receipt processing.
+    // The gateway also sends feedback_token as a header to survive this.
+    if (result && typeof result === "object" && !("feedback_token" in result)) {
+        const headerToken = response.headers.get("x-feedback-token");
+        if (headerToken) {
+            result.feedback_token = headerToken;
+        }
+    }
+    return result;
+}
+export async function apiPut(path, body) {
+    const url = `${getApiUrl()}${path}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(),
+        body: JSON.stringify(body),
+    });
+    return handleResponse(response);
+}

package/dist/core/config.d.ts

@@ -0,0 +1,77 @@
+export interface WalletEntry {
+    id: string;
+    keyType: "evm" | "ows";
+    key?: string;
+    owsWalletId?: string;
+    chains: string[];
+    defaultChain?: string;
+    label?: string;
+}
+export interface CardConfig {
+    consumerToken: string;
+    paymentMethodId?: string;
+    last4: string;
+    brand: string;
+}
+export interface Config {
+    apiUrl: string;
+    apiKey: string | null;
+    userId: string | null;
+    wallets: WalletEntry[];
+    defaultWallet: string | null;
+    card: CardConfig | null;
+    favorites: string[];
+}
+/** All supported chain identifiers. */
+export declare const SUPPORTED_CHAINS: readonly ["tempo", "base", "solana"];
+export type Chain = (typeof SUPPORTED_CHAINS)[number];
+/**
+ * Map chain name to the protocol used for payment.
+ * All chains now use MPP protocol (mppx).
+ */
+export declare function chainProtocol(_chain: string): "mpp";
+export declare function getConfig(): Config;
+export declare function saveConfig(updates: Partial<Config>): void;
+export declare function getApiUrl(): string;
+export declare function getApiKey(): string | null;
+export declare function isAuthenticated(): boolean;
+/**
+ * Get all wallets from config + env var synthetic wallets.
+ */
+export declare function getWallets(): WalletEntry[];
+/**
+ * Get a wallet by its ID.
+ */
+export declare function getWalletById(id: string): WalletEntry | undefined;
+/**
+ * Get the default wallet. Priority:
+ * 1. Configured defaultWallet
+ * 2. First wallet in the array
+ * 3. First env-var wallet
+ */
+export declare function getDefaultWallet(): WalletEntry | undefined;
+/**
+ * Add a wallet entry. If a wallet with the same ID exists, replace it.
+ */
+export declare function addWallet(entry: WalletEntry): void;
+/**
+ * Remove a wallet by ID.
+ */
+export declare function removeWallet(id: string): void;
+/**
+ * Get card configuration.
+ */
+export declare function getCardConfig(): CardConfig | null;
+/**
+ * Resolve a payment method string to a wallet + chain.
+ * Accepts: wallet ID, chain name, or "card".
+ * Returns null if unresolvable.
+ */
+export declare function resolveWalletAndChain(method?: string): {
+    wallet: WalletEntry;
+    chain: string;
+} | null;
+export declare function getFavorites(): string[];
+export declare function addFavorite(agentId: string): void;
+export declare function removeFavorite(agentId: string): void;
+export declare function isFavorite(agentId: string): boolean;

package/dist/core/config.js

@@ -0,0 +1,297 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/** All supported chain identifiers. */
+export const SUPPORTED_CHAINS = ["tempo", "base", "solana"];
+/**
+ * Map chain name to the protocol used for payment.
+ * All chains now use MPP protocol (mppx).
+ */
+export function chainProtocol(_chain) {
+    return "mpp";
+}
+// ── Constants ──────────────────────────────────────────────────────
+const CONFIG_DIR = join(homedir(), ".agentwonderland");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const DEFAULT_API_URL = "https://api.agentwonderland.com";
+// ── Helpers ────────────────────────────────────────────────────────
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Migrate a legacy flat-field config to the new wallet array model.
+ * Returns the new Config, and if migration happened, writes it to disk.
+ */
+function migrateIfNeeded(raw) {
+    // If wallets array already exists, treat as new format
+    if (Array.isArray(raw.wallets)) {
+        return {
+            apiUrl: raw.apiUrl ?? DEFAULT_API_URL,
+            apiKey: raw.apiKey ?? null,
+            userId: raw.userId ?? null,
+            wallets: raw.wallets,
+            defaultWallet: raw.defaultWallet ?? null,
+            card: raw.card ?? null,
+            favorites: raw.favorites ?? [],
+        };
+    }
+    // Build wallets from legacy flat fields
+    const wallets = [];
+    let defaultWallet = null;
+    if (raw.tempoPrivateKey && raw.evmPrivateKey && raw.tempoPrivateKey === raw.evmPrivateKey) {
+        // Same key for both — create a single wallet with both chains
+        const chains = ["tempo", raw.chain ?? "base"];
+        const id = "wallet-1";
+        wallets.push({
+            id,
+            keyType: "evm",
+            key: raw.tempoPrivateKey,
+            chains: [...new Set(chains)],
+            defaultChain: raw.defaultPaymentMethod === "base" ? (raw.chain ?? "base") : "tempo",
+        });
+        defaultWallet = id;
+    }
+    else {
+        if (raw.tempoPrivateKey) {
+            const id = "tempo-1";
+            wallets.push({
+                id,
+                keyType: "evm",
+                key: raw.tempoPrivateKey,
+                chains: ["tempo"],
+                defaultChain: "tempo",
+            });
+            if (!defaultWallet || raw.defaultPaymentMethod === "tempo")
+                defaultWallet = id;
+        }
+        if (raw.evmPrivateKey) {
+            const chain = raw.chain ?? "base";
+            const id = "evm-1";
+            wallets.push({
+                id,
+                keyType: "evm",
+                key: raw.evmPrivateKey,
+                chains: [chain],
+                defaultChain: chain,
+            });
+            if (!defaultWallet || raw.defaultPaymentMethod === "base")
+                defaultWallet = id;
+        }
+    }
+    // Migrate card
+    let card = null;
+    if (raw.stripeConsumerToken && raw.cardLast4) {
+        card = {
+            consumerToken: raw.stripeConsumerToken,
+            paymentMethodId: raw.stripePaymentMethodId ?? undefined,
+            last4: raw.cardLast4,
+            brand: raw.cardBrand ?? "card",
+        };
+    }
+    // If default payment was card and no wallet default set
+    if (raw.defaultPaymentMethod === "card" && !defaultWallet && wallets.length > 0) {
+        defaultWallet = wallets[0].id;
+    }
+    const config = {
+        apiUrl: raw.apiUrl ?? DEFAULT_API_URL,
+        apiKey: raw.apiKey ?? null,
+        userId: raw.userId ?? null,
+        wallets,
+        defaultWallet,
+        card,
+        favorites: [],
+    };
+    // Write migrated config (only if there was something to migrate)
+    if (raw.tempoPrivateKey || raw.evmPrivateKey || raw.stripeConsumerToken) {
+        ensureConfigDir();
+        writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    }
+    return config;
+}
+// ── Public API ─────────────────────────────────────────────────────
+export function getConfig() {
+    const defaults = {
+        apiUrl: DEFAULT_API_URL,
+        apiKey: null,
+        userId: null,
+        wallets: [],
+        defaultWallet: null,
+        card: null,
+        favorites: [],
+    };
+    if (!existsSync(CONFIG_FILE)) {
+        return defaults;
+    }
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        return migrateIfNeeded(parsed);
+    }
+    catch {
+        return defaults;
+    }
+}
+export function saveConfig(updates) {
+    ensureConfigDir();
+    const current = getConfig();
+    const merged = { ...current, ...updates };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+export function getApiUrl() {
+    const envUrl = process.env.AGENTWONDERLAND_API_URL;
+    if (envUrl)
+        return envUrl;
+    return getConfig().apiUrl;
+}
+export function getApiKey() {
+    const envKey = process.env.AGENTWONDERLAND_API_KEY;
+    if (envKey)
+        return envKey;
+    return getConfig().apiKey;
+}
+export function isAuthenticated() {
+    return getApiKey() !== null;
+}
+// ── Wallet helpers ─────────────────────────────────────────────────
+/**
+ * Get all wallets from config + env var synthetic wallets.
+ */
+export function getWallets() {
+    const wallets = [...getConfig().wallets];
+    // Env var support: TEMPO_PRIVATE_KEY creates a synthetic wallet
+    const tempoEnv = process.env.TEMPO_PRIVATE_KEY;
+    if (tempoEnv && !wallets.some((w) => w.id === "env-tempo")) {
+        wallets.push({
+            id: "env-tempo",
+            keyType: "evm",
+            key: tempoEnv,
+            chains: ["tempo"],
+            defaultChain: "tempo",
+            label: "Tempo (env)",
+        });
+    }
+    // Env var support: EVM_PRIVATE_KEY creates a synthetic wallet
+    const evmEnv = process.env.EVM_PRIVATE_KEY;
+    if (evmEnv && !wallets.some((w) => w.id === "env-evm")) {
+        wallets.push({
+            id: "env-evm",
+            keyType: "evm",
+            key: evmEnv,
+            chains: ["base"],
+            defaultChain: "base",
+            label: "Base (env)",
+        });
+    }
+    return wallets;
+}
+/**
+ * Get a wallet by its ID.
+ */
+export function getWalletById(id) {
+    return getWallets().find((w) => w.id === id);
+}
+/**
+ * Get the default wallet. Priority:
+ * 1. Configured defaultWallet
+ * 2. First wallet in the array
+ * 3. First env-var wallet
+ */
+export function getDefaultWallet() {
+    const wallets = getWallets();
+    if (wallets.length === 0)
+        return undefined;
+    const config = getConfig();
+    if (config.defaultWallet) {
+        const found = wallets.find((w) => w.id === config.defaultWallet);
+        if (found)
+            return found;
+    }
+    return wallets[0];
+}
+/**
+ * Add a wallet entry. If a wallet with the same ID exists, replace it.
+ */
+export function addWallet(entry) {
+    const config = getConfig();
+    const existing = config.wallets.findIndex((w) => w.id === entry.id);
+    if (existing >= 0) {
+        config.wallets[existing] = entry;
+    }
+    else {
+        config.wallets.push(entry);
+    }
+    // If no default wallet, set this as default
+    if (!config.defaultWallet) {
+        config.defaultWallet = entry.id;
+    }
+    saveConfig({ wallets: config.wallets, defaultWallet: config.defaultWallet });
+}
+/**
+ * Remove a wallet by ID.
+ */
+export function removeWallet(id) {
+    const config = getConfig();
+    config.wallets = config.wallets.filter((w) => w.id !== id);
+    // If we removed the default, pick the first remaining
+    if (config.defaultWallet === id) {
+        config.defaultWallet = config.wallets[0]?.id ?? null;
+    }
+    saveConfig({ wallets: config.wallets, defaultWallet: config.defaultWallet });
+}
+/**
+ * Get card configuration.
+ */
+export function getCardConfig() {
+    return getConfig().card;
+}
+/**
+ * Resolve a payment method string to a wallet + chain.
+ * Accepts: wallet ID, chain name, or "card".
+ * Returns null if unresolvable.
+ */
+export function resolveWalletAndChain(method) {
+    const wallets = getWallets();
+    if (!method) {
+        // Use default wallet with its default chain
+        const def = getDefaultWallet();
+        if (!def)
+            return null;
+        return { wallet: def, chain: def.defaultChain ?? def.chains[0] };
+    }
+    // Try as wallet ID first
+    const byId = wallets.find((w) => w.id === method);
+    if (byId) {
+        return { wallet: byId, chain: byId.defaultChain ?? byId.chains[0] };
+    }
+    // Try as chain name
+    const byChain = wallets.find((w) => w.chains.includes(method));
+    if (byChain) {
+        return { wallet: byChain, chain: method };
+    }
+    return null;
+}
+// ── Favorites helpers ───────────────────────────────────────────────
+export function getFavorites() {
+    return getConfig().favorites ?? [];
+}
+export function addFavorite(agentId) {
+    const config = getConfig();
+    if (!config.favorites)
+        config.favorites = [];
+    if (!config.favorites.includes(agentId)) {
+        config.favorites.push(agentId);
+        saveConfig(config);
+    }
+}
+export function removeFavorite(agentId) {
+    const config = getConfig();
+    if (!config.favorites)
+        return;
+    config.favorites = config.favorites.filter(id => id !== agentId);
+    saveConfig(config);
+}
+export function isFavorite(agentId) {
+    return getFavorites().includes(agentId);
+}

package/dist/core/formatters.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Shared display formatters for human-readable MCP and CLI output.
+ * Plain text only — no ANSI color codes.
+ */
+export declare function stars(rating: number | null | undefined): string;
+export declare function compactNumber(n: number | null | undefined): string;
+export declare function formatBytes(bytes: number): string;
+export declare function isFileOutput(output: unknown): output is {
+    type: "file";
+    url: string;
+    mime_type?: string;
+    size_bytes?: number;
+};
+export declare function formatPrice(pricePer1kTokens?: string | null, pricingModel?: string | null): string;
+interface AgentLike {
+    id?: string;
+    name?: string;
+    avgRating?: number | null;
+    ratingCount?: number;
+    totalExecutions?: number;
+    pricePer1kTokens?: string;
+    pricingModel?: string;
+    stats?: {
+        completedJobs?: number;
+        avgRating?: number | null;
+    };
+    [key: string]: unknown;
+}
+export declare function agentLine(agent: AgentLike): string;
+export declare function formatLastActive(lastActiveAt: string | null | undefined): string | null;
+export declare function agentList(agents: AgentLike[], query?: string): string;
+interface RunResultLike {
+    job_id?: string;
+    status?: string;
+    agent_id?: string;
+    agent_name?: string;
+    output?: unknown;
+    latency_ms?: number;
+    execution_latency_ms?: number;
+    cost?: number;
+    estimated_cost?: number;
+    input_tokens?: number;
+    tags?: string[];
+}
+export declare function formatRunResult(result: RunResultLike, opts?: {
+    paymentMethod?: string;
+}): string;
+/**
+ * Hint about what output type an agent typically returns, based on its tags.
+ * Returns null if no file-related tags found.
+ */
+export declare function outputTypeHint(tags?: string[] | null): string | null;
+export declare function agentWebUrl(agentId: string): string;
+export declare function formatFeedbackSummary(stats: Record<string, unknown>): string;
+interface WalletStatusEntry {
+    id: string;
+    chains: string[];
+    address?: string | null;
+    label?: string;
+    isDefault?: boolean;
+}
+interface WalletInfo {
+    wallets: WalletStatusEntry[];
+    card?: {
+        brand: string;
+        last4: string;
+    } | null;
+}
+export declare function formatWalletStatus(info: WalletInfo): string;
+export {};