@agentwonderland/mcp 0.1.23 → 0.1.25

package/dist/tools/solve.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
 import { apiGet, apiPost, apiPostWithPayment } from "../core/api-client.js";
-import { initiateCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
-import { hasWalletConfigured, getConfiguredMethods, getAcceptedPaymentMethods, getWalletAddress, } from "../core/payments.js";
+import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
+import { getCompatiblePaymentMethods, hasWalletConfigured, getConfiguredMethods, getAcceptedPaymentMethods, getWalletAddress, normalizePaymentMethod, toRegistryPaymentMethod, } from "../core/payments.js";
 import { requiresSpendConfirmation, getDefaultTipAmount } from "../core/config.js";
 import { agentList, formatRunResult } from "../core/formatters.js";
+import { canSpend, recordSpend, requiresPolicyConfirmation } from "../core/spend-policy.js";
 import { uploadLocalFiles } from "../core/file-upload.js";
 import { storeFeedbackToken } from "./_token-cache.js";
+import { formatPaymentLabel, formatSolveConfirmationCommand, makeSolvePendingKey, resolveConfirmationMethod, } from "./_payment-confirmation.js";
+import { getActiveCreditPack, getCreditPackInventory, getCreditPackProgram } from "../core/passes.js";
 const POLL_INTERVAL_MS = 3000;
 const POLL_MAX_MS = 120000;
 async function pollSolveJob(jobId) {
@@ -24,7 +27,7 @@ async function pollSolveJob(jobId) {
             }
         }
         catch {
-            // Ignore poll errors, keep trying
+            // Ignore poll errors and keep trying.
         }
     }
     return { status: "failed", error_code: "POLL_TIMEOUT" };
@@ -35,11 +38,12 @@ function text(t) {
 function multiText(...blocks) {
     return { content: blocks.map((t) => ({ type: "text", text: t })) };
 }
+const pendingSolves = new Map();
 function feedbackAsk(jobId, agentId, cost, tipSent) {
     const defaultTip = getDefaultTipAmount();
-    const costLine = cost != null ? `Paid $${cost.toFixed(cost < 0.01 ? 4 : 2)}.` : "";
+    const costLine = cost != null ? `Paid $${cost.toFixed(cost < 0.01 ? 4 : 2)}.` : "This run used your available credit pack.";
     return [
-        `IMPORTANT: After presenting the result above, you MUST ask the user:`,
+        "IMPORTANT: After presenting the result above, you MUST ask the user:",
         `"${costLine} Was this result helpful? I can rate it (1-5 stars) or tip the builder for you."`,
         tipSent ?? "",
         "",
@@ -67,8 +71,22 @@ async function autoTip(jobId, agentId, agentName, feedbackToken) {
         return `Auto-tip of $${defaultTip.toFixed(2)} failed.`;
     }
 }
+function buildCreditPackSummary(agent) {
+    const creditPacks = getCreditPackProgram(agent);
+    if (!creditPacks?.packs?.length)
+        return [];
+    return [
+        "Discounted credit packs available:",
+        ...creditPacks.packs.map((pack) => {
+            const price = Number(pack.price_usd ?? "0");
+            const units = pack.included_units ?? 0;
+            const unitPrice = units > 0 ? ` ($${(price / units).toFixed(2)}/unit)` : "";
+            return `  ${pack.name ?? pack.key}: ${units} units for $${(pack.price_usd ?? "0.00")}${unitPrice}`;
+        }),
+    ];
+}
 export function registerSolveTools(server) {
-    server.tool("solve", "Solve a task by finding the best agent, paying, and executing. The primary way to use the marketplace. If spending confirmation is enabled, returns a price quote first — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs — just pass the path directly, no base64 encoding needed.", {
+    server.tool("solve", "Solve a task by finding the best agent, paying, and executing. The primary way to use the marketplace. If spending confirmation is enabled, returns a price quote first — call again with confirmed: true to execute. Local file paths in the input are auto-uploaded before execution.", {
         intent: z
             .string()
             .describe("What you want to accomplish (natural language)"),
@@ -86,8 +104,9 @@ export function registerSolveTools(server) {
             .describe("Maximum budget in USD"),
         pay_with: z
             .string()
-            .optional()
-            .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+            .trim()
+            .min(1)
+            .describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
         confirmed: z
             .boolean()
             .optional()
@@ -95,9 +114,8 @@ export function registerSolveTools(server) {
     }, async ({ intent, input, budget, pay_with, confirmed }) => {
         if (!hasWalletConfigured()) {
             try {
-                const { qr, url } = await initiateCardSetup();
-                const blocks = formatCardSetupBlocks(qr, url);
-                return { content: blocks.map((t) => ({ type: "text", text: t })) };
+                const { url } = await getOrCreatePendingCardSetup();
+                return multiText(...formatCardSetupBlocks(url));
             }
             catch {
                 return text("No payment method configured.\n\n" +
@@ -105,8 +123,15 @@ export function registerSolveTools(server) {
                     "To use crypto: wallet_setup({ action: \"create\" })");
             }
         }
-        const method = pay_with ?? getConfiguredMethods()[0];
-        // Path 1: If authenticated, use the platform /solve route
+        const pendingKey = makeSolvePendingKey(intent, input, budget);
+        const pending = pendingSolves.get(pendingKey);
+        const configuredMethods = getConfiguredMethods();
+        const requestedMethod = pay_with;
+        const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
+        if (!normalizedRequestedMethod) {
+            return text(`Payment method "${requestedMethod}" is not configured.\n\n` +
+                "Use wallet_status to review your current payment methods.");
+        }
         let processedInput;
         try {
             const uploadResult = await uploadLocalFiles(input);
@@ -129,8 +154,9 @@ export function registerSolveTools(server) {
                 storeFeedbackToken(jobId, result.feedback_token, agentId);
             }
             const cost = result.cost;
+            const usedCreditPack = result.consumption_mode === "credit_pack";
             const tipMsg = result.feedback_token ? await autoTip(jobId, agentId, agentName, result.feedback_token) : "";
-            return multiText(formatRunResult(result), feedbackAsk(jobId, agentId, cost, tipMsg));
+            return multiText(formatRunResult(result), feedbackAsk(jobId, agentId, usedCreditPack ? undefined : cost, tipMsg));
         }
         catch (err) {
             const isAuthError = err instanceof Error &&
@@ -139,9 +165,10 @@ export function registerSolveTools(server) {
             if (!isAuthError || !hasWalletConfigured())
                 throw err;
         }
-        // Path 2: Wallet-only discovery — find agents, pick best, pay via MPP
         const params = new URLSearchParams({ q: intent, limit: "5" });
-        const acceptedMethods = getAcceptedPaymentMethods();
+        const acceptedMethods = requestedMethod
+            ? [toRegistryPaymentMethod(requestedMethod)].filter((value) => !!value)
+            : getAcceptedPaymentMethods();
         if (acceptedMethods.length > 0) {
             params.set("accepted_payment_methods", acceptedMethods.join(","));
         }
@@ -149,64 +176,97 @@ export function registerSolveTools(server) {
         if (!agents || agents.length === 0) {
             return text(`No agents found matching "${intent}".`);
         }
-        // Show discovery results
         const discovery = agentList(agents, intent);
-        // Pick cheapest agent within budget
-        const inputTokens = Math.ceil(JSON.stringify(input).length / 4);
-        const affordable = agents.filter((a) => {
-            const price = parseFloat(a.pricePer1kTokens ?? "0.01");
-            const cost = a.pricingModel === "fixed" ? price : (inputTokens / 1000) * price;
-            return cost <= budget;
+        const affordable = agents.filter((agent) => {
+            const price = parseFloat(agent.pricePerRunUsd ?? "0.01");
+            return price <= budget;
         });
         const selected = affordable[0] ?? agents[0];
-        const selectedPrice = parseFloat(selected.pricePer1kTokens ?? "0.01");
-        const estimatedCost = selected.pricingModel === "fixed"
-            ? selectedPrice
-            : (inputTokens / 1000) * selectedPrice;
-        // Confirmation step: show discovery + price, wait for confirmed: true
-        if (requiresSpendConfirmation() && !confirmed) {
+        const activeCreditPack = await getCreditPackInventory(selected.id).then(getActiveCreditPack);
+        const compatibleMethods = getCompatiblePaymentMethods(selected, configuredMethods);
+        if (!compatibleMethods.includes(normalizedRequestedMethod)) {
+            return text(`The best matching agent cannot be paid with "${requestedMethod}".\n\n` +
+                `Available payment methods for ${selected.name}: ${compatibleMethods.join(", ") || "none"}.\n` +
+                "Choose another payment method or refine your search.");
+        }
+        const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+        const spendCheckMethod = method ?? normalizedRequestedMethod;
+        const selectedPrice = parseFloat(selected.pricePerRunUsd ?? "0.01");
+        const estimatedCost = selectedPrice;
+        const needsPolicyConfirmation = !activeCreditPack && requiresPolicyConfirmation(spendCheckMethod, estimatedCost);
+        if (!activeCreditPack && (requiresSpendConfirmation() || needsPolicyConfirmation) && !confirmed) {
+            pendingSolves.set(pendingKey, { method });
             return text([
                 discovery,
                 "",
                 `Best match: ${selected.name}`,
                 `Cost: $${estimatedCost.toFixed(2)}`,
-                `Payment: ${method}`,
+                `Payment: ${formatPaymentLabel(method)}`,
+                ...(() => {
+                    const summary = buildCreditPackSummary(selected);
+                    return summary.length > 0 ? ["", ...summary] : [];
+                })(),
                 "",
                 "To proceed, call:",
-                `  solve({ intent: "${intent}", input: <same>, budget: ${budget}, confirmed: true })`,
+                formatSolveConfirmationCommand(intent, budget, method),
                 "",
                 "To cancel, do nothing.",
             ].join("\n"));
         }
         let result;
-        let processedInput2;
-        try {
-            const uploadResult2 = await uploadLocalFiles(input);
-            processedInput2 = uploadResult2.input;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : "File upload failed";
-            return text(`Error: ${msg}`);
+        if (!activeCreditPack) {
+            const spendCheck = canSpend({
+                method: spendCheckMethod,
+                amountUsd: estimatedCost,
+            });
+            if (!spendCheck.ok) {
+                return text(spendCheck.message);
+            }
         }
         try {
-            result = await apiPostWithPayment(`/agents/${selected.id}/run`, { input: processedInput2 }, method);
+            let usedPaidMethod = !activeCreditPack;
+            if (activeCreditPack) {
+                try {
+                    result = await apiPost(`/agents/${selected.id}/run`, { input: processedInput }, { ensureConsumerPrincipal: true });
+                }
+                catch (packErr) {
+                    const packApiErr = packErr;
+                    if (packApiErr?.status !== 402)
+                        throw packErr;
+                    result = await apiPostWithPayment(`/agents/${selected.id}/run`, { input: processedInput }, method);
+                    usedPaidMethod = true;
+                }
+            }
+            else {
+                result = await apiPostWithPayment(`/agents/${selected.id}/run`, { input: processedInput }, method);
+            }
+            if (usedPaidMethod) {
+                recordSpend(spendCheckMethod, estimatedCost);
+            }
         }
         catch (err) {
             const apiErr = err;
             if (apiErr?.status === 402) {
-                return text("Payment failed — your wallet may not have enough USDC.\n\n" +
-                    "Check your balance and fund your wallet, then try again.\n" +
-                    "Use wallet_status to check your current payment methods.");
+                return text([
+                    "Payment failed — your wallet may not have enough funds or the selected method was rejected.",
+                    "",
+                    "Check your balance and try again.",
+                    "Use wallet_status to check your current payment methods.",
+                    ...(() => {
+                        const summary = buildCreditPackSummary(selected);
+                        return summary.length > 0 ? ["", ...summary] : [];
+                    })(),
+                ].join("\n"));
             }
             return text(`Error: ${apiErr?.message ?? "Failed to run agent"}`);
         }
+        pendingSolves.delete(pendingKey);
         const jobId = result.job_id ?? "";
-        const agentId2 = result.agent_id ?? selected.id;
+        const agentId = result.agent_id ?? selected.id;
         const status = result.status;
         if (result.feedback_token) {
-            storeFeedbackToken(jobId, result.feedback_token, agentId2);
+            storeFeedbackToken(jobId, result.feedback_token, agentId);
         }
-        // Async agent — poll until complete
         if (status === "processing") {
             const pollResult = await pollSolveJob(jobId);
             if (pollResult.status === "completed") {
@@ -224,9 +284,9 @@ export function registerSolveTools(server) {
                     asyncFormatted,
                 ].join("\n");
                 const asyncCost = result.cost;
-                return multiText(asyncOutput, feedbackAsk(jobId, agentId2, asyncCost, ""));
+                const usedCreditPack = result.consumption_mode === "credit_pack";
+                return multiText(asyncOutput, feedbackAsk(jobId, agentId, usedCreditPack ? undefined : asyncCost, ""));
             }
-            // Async agent failed
             const failedFormatted = formatRunResult({
                 ...result,
                 status: "failed",
@@ -240,10 +300,14 @@ export function registerSolveTools(server) {
                 "",
                 failedFormatted,
             ].join("\n");
-            return multiText(failedOutput, "The agent execution failed. A refund has been initiated automatically.");
+            const usedCreditPack = result.consumption_mode === "credit_pack";
+            return multiText(failedOutput, usedCreditPack
+                ? "The agent execution failed and the reserved credit-pack unit was released automatically."
+                : "The agent execution failed. A refund has been initiated automatically.");
         }
         const actualCost = result.cost;
-        const tipMsg = result.feedback_token ? await autoTip(jobId, agentId2, selected.name ?? "", result.feedback_token) : "";
+        const usedCreditPack = result.consumption_mode === "credit_pack";
+        const tipMsg = result.feedback_token ? await autoTip(jobId, agentId, selected.name ?? "", result.feedback_token) : "";
         const output = [
             discovery,
             "",
@@ -252,6 +316,6 @@ export function registerSolveTools(server) {
             "",
             formatRunResult(result, { paymentMethod: method }),
         ].join("\n");
-        return multiText(output, feedbackAsk(jobId, agentId2, actualCost, tipMsg));
+        return multiText(output, feedbackAsk(jobId, agentId, usedCreditPack ? undefined : actualCost, tipMsg));
     });
 }

package/dist/tools/wallet.js

@@ -1,30 +1,50 @@
 import { z } from "zod";
-import { getWallets, getCardConfig, setCardConfig, addWallet } from "../core/config.js";
+import { getWallets, getCardConfig, setCardConfig, addWallet, getPendingCardSetupToken, getSpendPolicy, setSpendPolicy, } from "../core/config.js";
 import { getWalletAddress } from "../core/payments.js";
-import { initiateCardSetup, pollCardSetup } from "../core/card-setup.js";
-import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, } from "../core/ows-adapter.js";
+import { getOrCreatePendingCardSetup, formatCardSetupBlocks, getCardCapabilities, pollCardSetup, } from "../core/card-setup.js";
+import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, listOwsWalletsByChain, } from "../core/ows-adapter.js";
+import { ensureConsumerPrincipal, getConsumerPrincipal } from "../core/principal.js";
 function text(t) {
     return { content: [{ type: "text", text: t }] };
 }
-// Pending card setup — stored between the QR display call and the confirmation poll
-let pendingCardSetup = null;
 export function registerWalletTools(server) {
     // ── wallet_status (extracted from check_wallet) ─────────────────
     server.tool("wallet_status", "Check payment readiness. Shows all configured wallets, their chains, addresses, and card status.", {}, async () => {
         const wallets = getWallets();
         const card = getCardConfig();
-        if (wallets.length === 0 && !card) {
+        const pendingCardSetupToken = getPendingCardSetupToken();
+        const consumerPrincipal = await getConsumerPrincipal();
+        if (wallets.length === 0 && !card && !pendingCardSetupToken) {
             return text("No payment methods configured.\nUse wallet_setup to create or import a wallet.");
         }
         const lines = ["Payment methods:"];
         for (const w of wallets) {
-            const addr = await getWalletAddress(w.id);
             const label = w.label ? ` (${w.label})` : "";
             const storage = w.keyType === "ows" ? " [encrypted]" : " [plaintext]";
-            lines.push(`  ${w.id}${label}${storage}: ${w.chains.join(", ")} \u2014 ${addr ?? "unknown"}`);
+            const chainAddresses = await Promise.all(w.chains.map(async (chainName) => {
+                const addr = await getWalletAddress(chainName);
+                return `${chainName}: ${addr ?? "unknown"}`;
+            }));
+            lines.push(`  ${w.id}${label}${storage}: ${chainAddresses.join(" | ")}`);
         }
         if (card) {
             lines.push(`  Card: ${card.brand} ****${card.last4}`);
+            const capabilities = await getCardCapabilities();
+            if (capabilities.spt_status === "enabled") {
+                lines.push("  Card MPP: ready");
+            }
+            else if (capabilities.spt_status === "unavailable") {
+                lines.push(`  Card MPP: unavailable — ${capabilities.message ?? "Stripe Shared Payment Token access is not enabled."}`);
+            }
+            else {
+                lines.push(`  Card MPP: unknown — ${capabilities.message ?? "Could not determine card payment readiness."}`);
+            }
+        }
+        if (pendingCardSetupToken) {
+            lines.push("  Card setup: pending confirmation");
+        }
+        if (consumerPrincipal) {
+            lines.push("", `Consumer principal: ${consumerPrincipal}`);
         }
         return text(lines.join("\n"));
     });
@@ -42,7 +62,7 @@ export function registerWalletTools(server) {
             .optional()
             .describe("Private key hex string (required for 'import', ignored for 'create')"),
         chain: z.enum(["tempo", "base", "solana"]).optional()
-            .describe("Primary chain (default: tempo). Solana support is via Stripe deposit mode."),
+            .describe("Primary chain (default: tempo). Solana uses an OWS wallet plus Stripe deposit-mode USDC."),
     }, async ({ action, name, key, chain }) => {
         // ── Card setup flow ──────────────────────────────────────
         if (action === "add-card") {
@@ -50,48 +70,32 @@ export function registerWalletTools(server) {
             if (existing) {
                 return text(`Card already connected: ${existing.brand} ****${existing.last4}\n\nTo replace it, remove the current card first.`);
             }
+            const pendingToken = getPendingCardSetupToken();
             // Check if there's a pending setup to complete (user said they're done)
-            if (pendingCardSetup) {
-                const pendingToken = pendingCardSetup.token;
-                const result = await pollCardSetup(pendingToken, 120_000);
-                pendingCardSetup = null;
+            if (pendingToken) {
+                const result = await pollCardSetup(pendingToken, 250);
                 if (result) {
-                    return text(`Connected! ${result.brand} ****${result.last4} is ready for payments.`);
+                    const principal = await ensureConsumerPrincipal();
+                    return text(`Connected! ${result.brand} ****${result.last4} is ready for payments.\n\n` +
+                        `Consumer principal: ${principal}`);
                 }
-                return text("Card setup timed out. Run wallet_setup({ action: \"add-card\" }) to try again.");
-            }
-            // Create new card setup session with QR code, then auto-poll
-            try {
-                const { qr, url, token } = await initiateCardSetup();
-                // Auto-poll for up to 90 seconds — if the user enters their card
-                // quickly, the tool returns success without a second call
-                const result = await pollCardSetup(token, 90_000);
-                if (result) {
+                try {
+                    const { url } = await getOrCreatePendingCardSetup();
+                    const blocks = formatCardSetupBlocks(url);
                     return {
-                        content: [
-                            { type: "text", text: "\n" + qr.trim() },
-                            { type: "text", text: [
-                                    `Open to connect a card: ${url}`,
-                                    "",
-                                    `Connected! ${result.brand} ****${result.last4} is ready for payments.`,
-                                ].join("\n") },
-                        ],
+                        content: blocks.map((t) => ({ type: "text", text: t })),
                     };
                 }
-                // Timed out — save token for manual follow-up
-                pendingCardSetup = { token };
+                catch {
+                    return text("Card setup timed out. Run wallet_setup({ action: \"add-card\" }) to try again.");
+                }
+            }
+            // Create new card setup session and return immediately so clients
+            // don't appear hung while the user is still in the browser flow.
+            try {
+                const { url } = await getOrCreatePendingCardSetup();
                 return {
-                    content: [
-                        { type: "text", text: "\n" + qr.trim() },
-                        { type: "text", text: [
-                                `IMPORTANT: Present this link to the user to connect a payment card:`,
-                                "",
-                                url,
-                                "",
-                                `Tell the user: "Scan the QR code above or open this link to connect your card. Let me know when you're done."`,
-                                `After they confirm, call wallet_setup({ action: "add-card" }) to complete setup.`,
-                            ].join("\n") },
-                    ],
+                    content: formatCardSetupBlocks(url).map((t) => ({ type: "text", text: t })),
                 };
             }
             catch {
@@ -113,16 +117,20 @@ export function registerWalletTools(server) {
         }
         const selectedChains = chain === "solana" ? ["solana"] : ["tempo", "base"];
         const defaultCh = chain ?? "tempo";
+        const preferredOwsChain = defaultCh === "solana" ? "solana" : "evm";
         const owsReady = await isOwsAvailable();
         if (action === "create") {
             // Check for existing OWS wallets first
             if (owsReady) {
-                const existing = await listOwsWallets();
+                const existing = preferredOwsChain === "solana"
+                    ? await listOwsWalletsByChain("solana")
+                    : await listOwsWallets();
                 if (existing.length > 0) {
                     const w = existing[0];
                     // Check if already in config
                     const wallets = getWallets();
-                    const alreadyLinked = wallets.find(wl => wl.owsWalletId === w.id);
+                    const alreadyLinked = wallets.find((wl) => wl.owsWalletId === w.id);
+                    let chainStatus = "Linked to Agent Wonderland.";
                     if (!alreadyLinked) {
                         addWallet({
                             id: w.name,
@@ -133,14 +141,29 @@ export function registerWalletTools(server) {
                             label: w.name,
                         });
                     }
+                    else {
+                        const mergedChains = [...new Set([...alreadyLinked.chains, ...selectedChains])];
+                        if (mergedChains.length !== alreadyLinked.chains.length) {
+                            addWallet({
+                                ...alreadyLinked,
+                                chains: mergedChains,
+                            });
+                            chainStatus = `Updated linked chains: ${mergedChains.join(", ")}.`;
+                        }
+                        else {
+                            chainStatus = "Already linked to Agent Wonderland.";
+                        }
+                    }
+                    const principal = await ensureConsumerPrincipal();
                     return text([
                         "Found existing OWS wallet:",
                         `  Name: ${w.name}`,
                         `  Address: ${w.address}`,
                         `  Chains: ${selectedChains.join(", ")}`,
                         `  Storage: ~/.ows/ (encrypted)`,
+                        `  Consumer principal: ${principal}`,
                         "",
-                        alreadyLinked ? "Already linked to Agent Wonderland." : "Linked to Agent Wonderland.",
+                        chainStatus,
                         "",
                         `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
                     ].join("\n"));
@@ -149,10 +172,12 @@ export function registerWalletTools(server) {
             if (!owsReady) {
                 return text("Cannot create wallet: OWS (Open Wallet Standard) is not installed.\n" +
                     "Install with: npm install -g @open-wallet-standard/core\n\n" +
-                    "Alternatively, use action 'import' with an existing private key.");
+                    (defaultCh === "solana"
+                        ? "Solana wallets currently require OWS-managed encrypted storage."
+                        : "Alternatively, use action 'import' with an existing private key."));
             }
             const walletName = name ?? `aw-${Date.now()}`;
-            const result = await createOwsWallet(walletName);
+            const result = await createOwsWallet(walletName, preferredOwsChain);
             // Persist to config so payment flows can find it
             addWallet({
                 id: walletName,
@@ -162,6 +187,7 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            const principal = await ensureConsumerPrincipal();
             return text([
                 `Wallet created [encrypted]:`,
                 `  ID: ${result.walletId}`,
@@ -169,6 +195,7 @@ export function registerWalletTools(server) {
                 `  Name: ${walletName}`,
                 `  Chains: ${selectedChains.join(", ")}`,
                 `  Storage: ~/.ows/ (AES-256-GCM encrypted)`,
+                `  Consumer principal: ${principal}`,
                 "",
                 `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
                 "For testnet: npx mppx account fund",
@@ -177,7 +204,7 @@ export function registerWalletTools(server) {
         // action === "import"
         if (owsReady) {
             const walletName = name ?? `imported-${Date.now()}`;
-            const result = await importKeyToOws(key, walletName);
+            const result = await importKeyToOws(key, walletName, preferredOwsChain);
             addWallet({
                 id: walletName,
                 keyType: "ows",
@@ -186,14 +213,20 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            const principal = await ensureConsumerPrincipal();
             return text([
                 `Key imported to OWS [encrypted]:`,
                 `  ID: ${result.walletId}`,
                 `  Address: ${result.address}`,
                 `  Name: ${walletName}`,
                 `  Chains: ${selectedChains.join(", ")}`,
+                `  Consumer principal: ${principal}`,
             ].join("\n"));
         }
+        if (defaultCh === "solana") {
+            return text("Solana key import currently requires OWS (Open Wallet Standard) so the ed25519 key can be stored safely.\n" +
+                "Install with: npm install -g @open-wallet-standard/core");
+        }
         // No OWS — store plaintext
         try {
             const { privateKeyToAccount } = await import("viem/accounts");
@@ -208,11 +241,13 @@ export function registerWalletTools(server) {
                 defaultChain: defaultCh,
                 label: walletName,
             });
+            const principal = await ensureConsumerPrincipal();
             return text([
                 `Key imported [plaintext] \u2014 OWS not available for encrypted storage.`,
                 `  Address: ${account.address}`,
                 `  Name: ${walletName}`,
                 `  Chains: ${selectedChains.join(", ")}`,
+                `  Consumer principal: ${principal}`,
                 "",
                 "Install OWS for encrypted storage: npm install -g @open-wallet-standard/core",
             ].join("\n"));
@@ -234,26 +269,42 @@ export function registerWalletTools(server) {
             .positive()
             .optional()
             .describe("Maximum USD per day across all transactions"),
-    }, async ({ wallet_id, max_per_tx, max_per_day }) => {
+        require_confirmation_above: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Require manual confirmation above this USD amount even when auto-spend is enabled"),
+    }, async ({ wallet_id, max_per_tx, max_per_day, require_confirmation_above }) => {
         const wallets = getWallets();
         const wallet = wallets.find((w) => w.id === wallet_id);
         if (!wallet) {
             const available = wallets.map((w) => w.id).join(", ") || "none";
             return text(`Wallet "${wallet_id}" not found. Available wallets: ${available}`);
         }
-        if (max_per_tx == null && max_per_day == null) {
-            return text("No policy changes specified. Provide max_per_tx and/or max_per_day.");
+        if (max_per_tx == null &&
+            max_per_day == null &&
+            require_confirmation_above == null) {
+            return text("No policy changes specified. Provide at least one policy field.");
         }
+        const existing = getSpendPolicy(wallet_id) ?? {};
+        const nextPolicy = {
+            ...existing,
+            ...(max_per_tx != null ? { maxPerTxUsd: max_per_tx } : {}),
+            ...(max_per_day != null ? { maxPerDayUsd: max_per_day } : {}),
+            ...(require_confirmation_above != null ? { requireConfirmationAboveUsd: require_confirmation_above } : {}),
+        };
+        setSpendPolicy(wallet_id, nextPolicy);
         // Build policy summary
         const policies = [];
-        if (max_per_tx != null) {
-            policies.push(`Max per transaction: $${max_per_tx.toFixed(2)}`);
+        if (nextPolicy.maxPerTxUsd != null) {
+            policies.push(`Max per transaction: $${nextPolicy.maxPerTxUsd.toFixed(2)}`);
+        }
+        if (nextPolicy.maxPerDayUsd != null) {
+            policies.push(`Max per day: $${nextPolicy.maxPerDayUsd.toFixed(2)}`);
         }
-        if (max_per_day != null) {
-            policies.push(`Max per day: $${max_per_day.toFixed(2)}`);
+        if (nextPolicy.requireConfirmationAboveUsd != null) {
+            policies.push(`Require confirmation above: $${nextPolicy.requireConfirmationAboveUsd.toFixed(2)}`);
         }
-        // Note: actual persistence depends on the config module supporting policy fields.
-        // For now, we report what would be set. The core/config module will handle storage.
         return text([
             `Spending policy set for wallet "${wallet_id}":`,
             ...policies.map((p) => `  ${p}`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {
@@ -23,6 +23,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
     "mppx": "^0.4.9",
     "qrcode": "^1.5.4",
     "viem": "^2.47.6",

package/src/core/__tests__/amount-utils.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { toAtomicAmount } from "../amount-utils.js";
+
+describe("toAtomicAmount", () => {
+  it("converts decimal USDC challenge amounts into atomic units", () => {
+    expect(toAtomicAmount("0.020000")).toBe(20000n);
+    expect(toAtomicAmount("1.000000")).toBe(1000000n);
+  });
+
+  it("supports different decimal precisions", () => {
+    expect(toAtomicAmount("0.50", 2)).toBe(50n);
+  });
+});