@agentwonderland/mcp 0.1.51 → 0.1.53

package/dist/core/__tests__/api-client.test.js

@@ -1,9 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPrincipalForMethod, mockGetConsumerPrincipalForMethod, mockGetBaseRebatePrincipal, mockPaymentFetch, } = vi.hoisted(() => ({
+import { MCP_PACKAGE_VERSION } from "../version.js";
+const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPrincipalForMethod, mockEnsureBaseRebatePrincipal, mockGetConsumerPrincipalForMethod, mockGetBaseRebatePrincipal, mockPaymentFetch, } = vi.hoisted(() => ({
     mockGetApiUrl: vi.fn(),
     mockGetApiKey: vi.fn(),
     mockGetPaymentFetch: vi.fn(),
     mockEnsureConsumerPrincipalForMethod: vi.fn(),
+    mockEnsureBaseRebatePrincipal: vi.fn(),
     mockGetConsumerPrincipalForMethod: vi.fn(),
     mockGetBaseRebatePrincipal: vi.fn(),
     mockPaymentFetch: vi.fn(),
@@ -17,6 +19,7 @@ vi.mock("../payments.js", () => ({
 }));
 vi.mock("../principal.js", () => ({
     ensureConsumerPrincipal: vi.fn(),
+    ensureBaseRebatePrincipal: (...args) => mockEnsureBaseRebatePrincipal(...args),
     ensureConsumerPrincipalForMethod: (...args) => mockEnsureConsumerPrincipalForMethod(...args),
     getConsumerPrincipal: vi.fn(),
     getConsumerPrincipalForMethod: (...args) => mockGetConsumerPrincipalForMethod(...args),
@@ -31,6 +34,7 @@ describe("api-client headers", () => {
         mockEnsureConsumerPrincipalForMethod.mockResolvedValue("did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF");
         mockGetConsumerPrincipalForMethod.mockResolvedValue("did:pkh:eip155:8453:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
         mockGetBaseRebatePrincipal.mockResolvedValue("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+        mockEnsureBaseRebatePrincipal.mockResolvedValue("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
         mockPaymentFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
             status: 200,
             headers: { "content-type": "application/json" },
@@ -46,7 +50,7 @@ describe("api-client headers", () => {
                 "X-AW-Consumer-Principal": "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
                 "X-AW-Rebate-Principal": "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                 "X-AW-Surface": "mcp",
-                "X-AW-MCP-Version": "0.1.44",
+                "X-AW-MCP-Version": MCP_PACKAGE_VERSION,
                 "X-AW-MCP-Tool": "run_agent",
                 "X-AW-MCP-Action": "execute",
             }),

package/dist/core/__tests__/link-cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/link-cli.test.js

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const { execCalls, outputs, state, mockExecFile, } = vi.hoisted(() => {
+    const execCalls = [];
+    const outputs = [];
+    const state = {
+        pending: null,
+        pendingWrites: [],
+    };
+    const mockExecFile = vi.fn((file, args, _options, callback) => {
+        execCalls.push({ file, args });
+        const next = outputs.shift();
+        if (next instanceof Error) {
+            callback(next);
+            return;
+        }
+        callback(null, JSON.stringify(next ?? null), "");
+    });
+    mockExecFile[Symbol.for("nodejs.util.promisify.custom")] = async (file, args) => {
+        execCalls.push({ file, args });
+        const next = outputs.shift();
+        if (next instanceof Error) {
+            throw next;
+        }
+        return { stdout: JSON.stringify(next ?? null), stderr: "" };
+    };
+    return { execCalls, outputs, state, mockExecFile };
+});
+vi.mock("node:child_process", () => ({
+    execFile: mockExecFile,
+}));
+vi.mock("../config.js", () => ({
+    getPendingLinkSpendRequest: () => state.pending,
+    setPendingLinkSpendRequest: (pending) => {
+        state.pending = pending;
+        state.pendingWrites.push(pending);
+    },
+    setLinkCooldown: vi.fn(),
+}));
+describe("Link CLI spend requests", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        execCalls.length = 0;
+        outputs.length = 0;
+        state.pending = null;
+        state.pendingWrites = [];
+    });
+    it("returns an approval-required error immediately instead of blocking on Link approval", async () => {
+        outputs.push([
+            {
+                id: "lsrq_test_123",
+                approval_url: "https://link.example/approve/lsrq_test_123",
+                status: "pending_approval",
+            },
+        ]);
+        const { createLinkSharedPaymentToken, LinkApprovalRequiredError } = await import("../link-cli.js");
+        await expect(createLinkSharedPaymentToken({
+            amount: "10",
+            currency: "usd",
+            context: "Agent Wonderland test",
+            expiresAt: Math.floor(Date.now() / 1000) + 300,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        })).rejects.toBeInstanceOf(LinkApprovalRequiredError);
+        expect(execCalls).toHaveLength(1);
+        expect(execCalls[0]?.args).toContain("create");
+        expect(state.pendingWrites[0]).toMatchObject({
+            id: "lsrq_test_123",
+            approvalUrl: "https://link.example/approve/lsrq_test_123",
+            amount: "10",
+            currency: "usd",
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        });
+    });
+    it("resumes a stored Link spend request and returns the approved shared payment token", async () => {
+        const expiresAt = Math.floor(Date.now() / 1000) + 300;
+        state.pending = {
+            id: "lsrq_test_123",
+            approvalUrl: "https://link.example/approve/lsrq_test_123",
+            amount: "10",
+            currency: "usd",
+            context: "Agent Wonderland test",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+            createdAt: new Date().toISOString(),
+        };
+        outputs.push({ shared_payment_token: "spt_test_123" });
+        const { createLinkSharedPaymentToken } = await import("../link-cli.js");
+        await expect(createLinkSharedPaymentToken({
+            amount: "10",
+            currency: "usd",
+            context: "Agent Wonderland test",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        })).resolves.toBe("spt_test_123");
+        expect(execCalls).toHaveLength(1);
+        expect(execCalls[0]?.args).toEqual(expect.arrayContaining(["spend-request", "retrieve", "lsrq_test_123"]));
+        expect(state.pendingWrites).toEqual([null]);
+    });
+});

package/dist/core/__tests__/principal.test.js

@@ -106,6 +106,19 @@ describe("consumer principal helpers", () => {
         expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
         expect(state.addedWallets).toHaveLength(1);
     });
+    it("creates an EVM identity for Link payments when only a Solana wallet exists", async () => {
+        state.wallets = [
+            { id: "sol-wallet", keyType: "ows", owsWalletId: "ows-sol", chains: ["solana"], defaultChain: "solana" },
+        ];
+        state.addresses = {
+            "sol-wallet": "42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+        };
+        const { ensureConsumerPrincipalForMethod } = await import("../principal.js");
+        const principal = await ensureConsumerPrincipalForMethod("link");
+        expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
+        expect(state.addedWallets).toHaveLength(1);
+        expect(state.addedWallets[0]?.chains).toEqual(["tempo", "base"]);
+    });
     it("returns the Base rebate principal when an EVM wallet is available", async () => {
         state.wallets = [
             { id: "aw-main", keyType: "ows", owsWalletId: "ows-main", chains: ["tempo", "base", "solana"], defaultChain: "tempo" },
@@ -119,4 +132,16 @@ describe("consumer principal helpers", () => {
         const principal = await getBaseRebatePrincipal();
         expect(principal).toBe("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
     });
+    it("ensures a Base rebate principal even when the default wallet is Solana-only", async () => {
+        state.wallets = [
+            { id: "sol-wallet", keyType: "ows", owsWalletId: "ows-sol", chains: ["solana"], defaultChain: "solana" },
+        ];
+        state.addresses = {
+            "sol-wallet": "42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+        };
+        const { ensureBaseRebatePrincipal } = await import("../principal.js");
+        const principal = await ensureBaseRebatePrincipal();
+        expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
+        expect(state.addedWallets).toHaveLength(1);
+    });
 });

package/dist/core/api-client.js

@@ -1,6 +1,6 @@
 import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
-import { getBaseRebatePrincipal, ensureConsumerPrincipalForMethod, getConsumerPrincipalForMethod, } from "./principal.js";
+import { getBaseRebatePrincipal, ensureBaseRebatePrincipal, ensureConsumerPrincipalForMethod, getConsumerPrincipalForMethod, } from "./principal.js";
 import { MCP_PACKAGE_VERSION } from "./version.js";
 // ── Error class ────────────────────────────────────────────────────
 export class ApiError extends Error {
@@ -49,7 +49,9 @@ async function buildHeaders(path, method, options) {
     if (principal) {
         headers["X-AW-Consumer-Principal"] = principal;
     }
-    const rebatePrincipal = await getBaseRebatePrincipal();
+    const rebatePrincipal = options?.ensureConsumerPrincipal
+        ? await ensureBaseRebatePrincipal()
+        : await getBaseRebatePrincipal();
     if (rebatePrincipal) {
         headers["X-AW-Rebate-Principal"] = rebatePrincipal;
     }

package/dist/core/link-cli.d.ts

@@ -1,3 +1,8 @@
+export declare class LinkApprovalRequiredError extends Error {
+    readonly spendRequestId: string;
+    readonly approvalUrl?: string | undefined;
+    constructor(spendRequestId: string, approvalUrl?: string | undefined);
+}
 export interface LinkCliAuthStatus {
     authenticated: boolean;
     credentialsPath?: string;

package/dist/core/link-cli.js

@@ -4,8 +4,23 @@ import { getPendingLinkSpendRequest, setLinkCooldown, setPendingLinkSpendRequest
 const execFileAsync = promisify(execFile);
 const LINK_CLI_PACKAGE = "@stripe/link-cli";
 const LINK_CLI_TIMEOUT_MS = 10 * 60 * 1000;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+export class LinkApprovalRequiredError extends Error {
+    spendRequestId;
+    approvalUrl;
+    constructor(spendRequestId, approvalUrl) {
+        super(formatLinkApprovalRequiredMessage(spendRequestId, approvalUrl));
+        this.spendRequestId = spendRequestId;
+        this.approvalUrl = approvalUrl;
+        this.name = "LinkApprovalRequiredError";
+    }
+}
+function formatLinkApprovalRequiredMessage(spendRequestId, approvalUrl) {
+    return [
+        "Link approval required.",
+        "The agent has not run yet and no charge has been captured.",
+        approvalUrl ? `Approve this spend request in Link: ${approvalUrl}` : `Spend request: ${spendRequestId}`,
+        "After approving, rerun the same tool call with confirmed: true.",
+    ].join("\n");
 }
 async function runLinkCli(args, timeout = LINK_CLI_TIMEOUT_MS) {
     try {
@@ -220,6 +235,9 @@ export async function createLinkSharedPaymentToken(params) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
+            if (err instanceof LinkApprovalRequiredError) {
+                throw err;
+            }
             if (!/denied|expired|not found|without a shared payment token|POLLING_TIMEOUT/i.test(message)) {
                 throw err;
             }
@@ -293,39 +311,21 @@ export async function createLinkSharedPaymentToken(params) {
         if (approval.approvalUrl) {
             console.error(`Link approval required: ${approval.approvalUrl}`);
         }
-        const retrievedSpt = await retrieveSharedPaymentToken(approval.id, approval.approvalUrl);
-        setPendingLinkSpendRequest(null);
-        return retrievedSpt;
+        throw new LinkApprovalRequiredError(approval.id, approval.approvalUrl);
     }
     {
         throw new Error("Link spend request completed without a shared payment token in the CLI response.");
     }
 }
 async function retrieveSharedPaymentToken(spendRequestId, approvalUrl) {
-    let retrieved = await runLinkCli([
+    const retrieved = await runLinkCli([
         "spend-request",
         "retrieve",
         spendRequestId,
-        "--interval",
-        "2",
-        "--max-attempts",
-        "150",
-    ]);
-    let retrievedSpt = extractSharedPaymentToken(retrieved);
-    for (let attempt = 0; !retrievedSpt && attempt < 30; attempt += 1) {
-        await sleep(2_000);
-        retrieved = await runLinkCli([
-            "spend-request",
-            "retrieve",
-            spendRequestId,
-        ]);
-        retrievedSpt = extractSharedPaymentToken(retrieved);
-    }
+    ], 30_000);
+    const retrievedSpt = extractSharedPaymentToken(retrieved);
     if (retrievedSpt) {
         return retrievedSpt;
     }
-    throw new Error([
-        "Link spend request finished without a shared payment token.",
-        approvalUrl ? `Approval URL: ${approvalUrl}` : undefined,
-    ].filter(Boolean).join("\n"));
+    throw new LinkApprovalRequiredError(spendRequestId, approvalUrl);
 }

package/dist/core/principal.d.ts

@@ -1,5 +1,6 @@
 export declare function getConsumerPrincipal(): Promise<string | null>;
 export declare function getBaseRebatePrincipal(): Promise<string | null>;
+export declare function ensureBaseRebatePrincipal(): Promise<string>;
 export declare function getConsumerPrincipalForMethod(method?: string): Promise<string | null>;
 export declare function ensureConsumerPrincipal(): Promise<string>;
 export declare function ensureConsumerPrincipalForMethod(method?: string): Promise<string>;

package/dist/core/principal.js

@@ -59,6 +59,40 @@ async function createFallbackIdentityWallet() {
     addWallet(entry);
     return entry;
 }
+async function ensureEvmIdentityWallet() {
+    const existing = preferredWallets().find((wallet) => walletSupportsEvm(wallet));
+    if (existing)
+        return existing;
+    if (await isOwsAvailable()) {
+        const existingOwsWallets = await listOwsWallets();
+        const linked = existingOwsWallets[0];
+        if (linked) {
+            const entry = {
+                id: linked.name,
+                keyType: "ows",
+                owsWalletId: linked.id,
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: linked.name,
+            };
+            addWallet(entry);
+            return entry;
+        }
+        const walletName = `aw-identity-${Date.now()}`;
+        const created = await createOwsWallet(walletName, "evm");
+        const entry = {
+            id: walletName,
+            keyType: "ows",
+            owsWalletId: created.walletId,
+            chains: ["tempo", "base"],
+            defaultChain: "base",
+            label: AUTO_IDENTITY_LABEL,
+        };
+        addWallet(entry);
+        return entry;
+    }
+    return createFallbackIdentityWallet();
+}
 async function ensureIdentityWallet() {
     const wallets = preferredWallets();
     const existing = wallets.find((wallet) => walletSupportsEvm(wallet) || walletSupportsSolana(wallet));
@@ -105,9 +139,20 @@ export async function getConsumerPrincipal() {
 export async function getBaseRebatePrincipal() {
     return (await principalForChain("base")) ?? principalForChain("tempo");
 }
+export async function ensureBaseRebatePrincipal() {
+    const existing = await getBaseRebatePrincipal();
+    if (existing)
+        return existing;
+    const wallet = await ensureEvmIdentityWallet();
+    const principal = await walletPrincipal(wallet);
+    if (!principal || !principal.startsWith(`did:pkh:eip155:${BASE_CHAIN_ID}:`)) {
+        throw new Error("Could not derive a Base rebate principal from the configured identity wallet.");
+    }
+    return principal;
+}
 export async function getConsumerPrincipalForMethod(method) {
     if (!method || method === "card" || method === "link") {
-        return getConsumerPrincipal();
+        return getBaseRebatePrincipal();
     }
     const resolved = resolveWalletAndChain(method);
     if (!resolved)
@@ -129,6 +174,9 @@ export async function ensureConsumerPrincipalForMethod(method) {
     const existing = await getConsumerPrincipalForMethod(method);
     if (existing)
         return existing;
+    if (!method || method === "card" || method === "link") {
+        return ensureBaseRebatePrincipal();
+    }
     if (method && method !== "card" && method !== "link") {
         throw new Error(`Could not derive a consumer principal for payment method "${method}". ` +
             "Check wallet_status and confirm that chain is configured for the active wallet.");

package/dist/index.js

@@ -12,6 +12,7 @@ import { registerWalletTools } from "./tools/wallet.js";
 import { registerFavoriteTools } from "./tools/favorites.js";
 import { registerTipTools } from "./tools/tip.js";
 import { registerPassTools } from "./tools/passes.js";
+import { registerRebateTools } from "./tools/rebates.js";
 import { registerUploadTools } from "./tools/upload.js";
 import { registerProbeTools } from "./tools/probe.js";
 import { registerProviderTools } from "./tools/providers.js";
@@ -64,6 +65,7 @@ export async function startMcpServer() {
             "",
             "WALLET HYGIENE:",
             "- wallet_status shows per-chain USDC balance and the active network (mainnet vs testnet).",
+            "- rebate_status shows accrued, pending, paid, and blocked consumer rebates plus recent payout transactions.",
             "- To set up payments: wallet_setup({ action: \"start\" }). Link card/bank is recommended for most users.",
             "- To create or import a crypto wallet directly: wallet_setup({ action: \"create\" }) or { action: \"import\", key }.",
             "- NEVER delete or rotate keys programmatically. Direct users to edit ~/.agentwonderland/config.json or ~/.ows/ manually.",
@@ -80,6 +82,7 @@ export async function startMcpServer() {
     registerFavoriteTools(server);
     registerTipTools(server);
     registerPassTools(server);
+    registerRebateTools(server);
     registerUploadTools(server);
     registerProbeTools(server);
     registerProviderTools(server);

package/dist/tools/__tests__/rebates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/rebates.test.js

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const { mockApiGet } = vi.hoisted(() => ({
+    mockApiGet: vi.fn(),
+}));
+vi.mock("../../core/api-client.js", () => ({
+    apiGet: (...args) => mockApiGet(...args),
+}));
+async function getRebateStatusTool() {
+    const tools = new Map();
+    const server = {
+        tool: (name, _description, _schema, handler) => {
+            tools.set(name, handler);
+        },
+    };
+    const { registerRebateTools } = await import("../rebates.js");
+    registerRebateTools(server);
+    const tool = tools.get("rebate_status");
+    if (!tool)
+        throw new Error("rebate_status tool was not registered");
+    return tool;
+}
+function flattenText(result) {
+    return result.content.map((item) => item.text).join("\n");
+}
+describe("rebate_status tool", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        mockApiGet.mockReset();
+    });
+    it("formats rebate balances and recent payouts", async () => {
+        mockApiGet.mockResolvedValueOnce({
+            consumer_principal: "did:pkh:eip155:8453:0xabc",
+            principal_type: "evm",
+            principal_value: "0xabc",
+            payout_address: "0xabc",
+            payout_chain: "base",
+            auto_payout_threshold_usd: "5.000000",
+            totals: {
+                lifetime_earned_usd: "2.500000",
+                pending_usd: "1.250000",
+                paid_usd: "1.000000",
+                blocked_usd: "0.250000",
+                total_count: 5,
+                pending_count: 2,
+                paid_count: 2,
+                blocked_count: 1,
+            },
+            by_source: [
+                { source_type: "job_execution", status: "earned", count: 2, rebate_usd: "1.250000" },
+            ],
+            recent_payouts: [
+                {
+                    id: "payout-1",
+                    status: "completed",
+                    amount_usd: "1.000000",
+                    earning_count: 2,
+                    tx_hash: "0xhash",
+                    processed_at: "2026-05-09T12:00:00.000Z",
+                },
+            ],
+        });
+        const tool = await getRebateStatusTool();
+        const result = await tool({});
+        const text = flattenText(result);
+        expect(mockApiGet).toHaveBeenCalledWith("/rebates/status", { ensureConsumerPrincipal: true });
+        expect(text).toContain("Lifetime earned: $2.5000 across 5 rebate(s)");
+        expect(text).toContain("Pending: $1.2500 across 2 rebate(s)");
+        expect(text).toContain("Auto payout: $3.7500 until the $5.0000 threshold");
+        expect(text).toContain("job execution / earned: $1.2500 (2)");
+        expect(text).toContain("completed: $1.0000 (2) tx=0xhash");
+    });
+});

package/dist/tools/__tests__/run.test.js

@@ -146,4 +146,30 @@ describe("run_agent MCP tool", () => {
         expect(text).toContain("Paid: $0.01 via card");
         expect(text).toContain("Job ID: job-1");
     });
+    it("returns Link approval instructions without wrapping them as an execution error", async () => {
+        mockGetConfiguredMethods.mockReturnValue(["link"]);
+        mockGetCompatiblePaymentMethods.mockReturnValue(["link"]);
+        mockApiPostWithPayment.mockRejectedValueOnce(new Error([
+            "Link approval required.",
+            "The agent has not run yet and no charge has been captured.",
+            "Approve this spend request in Link: https://link.example/approve/lsrq_test",
+            "After approving, rerun the same tool call with confirmed: true.",
+        ].join("\n")));
+        const { registerRunTools } = await import("../run.js");
+        const harness = makeServerHarness();
+        registerRunTools(harness.server);
+        const runAgent = harness.handlers.get("run_agent");
+        expect(runAgent).toBeDefined();
+        const result = await runAgent({
+            agent_id: selectedAgent.id,
+            input: { text: "hello", target_language: "es" },
+            pay_with: "link",
+            confirmed: true,
+        });
+        const text = flattenToolText(result);
+        expect(text).toContain("Link approval required.");
+        expect(text).toContain("https://link.example/approve/lsrq_test");
+        expect(text).not.toContain("Error: Link approval required.");
+        expect(mockRecordSpend).not.toHaveBeenCalled();
+    });
 });

package/dist/tools/__tests__/wallet.test.js

@@ -124,6 +124,7 @@ vi.mock("../../core/ows-adapter.js", () => ({
 }));
 vi.mock("../../core/principal.js", () => ({
     ensureConsumerPrincipal: async () => state.consumerPrincipal,
+    ensureConsumerPrincipalForMethod: async () => state.consumerPrincipal,
     getConsumerPrincipal: async () => state.consumerPrincipal,
 }));
 function resetState() {

package/dist/tools/index.d.ts

@@ -8,6 +8,7 @@ export { registerWalletTools } from "./wallet.js";
 export { registerFavoriteTools } from "./favorites.js";
 export { registerTipTools } from "./tip.js";
 export { registerPassTools } from "./passes.js";
+export { registerRebateTools } from "./rebates.js";
 export { registerUploadTools } from "./upload.js";
 export { registerProbeTools } from "./probe.js";
 export { registerProviderTools } from "./providers.js";

package/dist/tools/index.js

@@ -8,6 +8,7 @@ export { registerWalletTools } from "./wallet.js";
 export { registerFavoriteTools } from "./favorites.js";
 export { registerTipTools } from "./tip.js";
 export { registerPassTools } from "./passes.js";
+export { registerRebateTools } from "./rebates.js";
 export { registerUploadTools } from "./upload.js";
 export { registerProbeTools } from "./probe.js";
 export { registerProviderTools } from "./providers.js";

package/dist/tools/observability.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerObservabilityTools(server: McpServer): void;

package/dist/tools/observability.js

@@ -0,0 +1,20 @@
+import { apiPost } from "../core/api-client.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+export function registerObservabilityTools(server) {
+    server.tool("open_observability_dashboard", "Generate a secure one-click sign-in URL for the Agent Wonderland web observability dashboard. The dashboard shows your agent runs, spend, rebates, and recent activity.", {}, async () => {
+        const result = await apiPost("/observability/link", {}, { ensureConsumerPrincipal: true });
+        const lines = [
+            "Your secure observability link is ready:",
+            result.url,
+            "",
+            `Expires: ${result.expires_at}`,
+        ];
+        if (result.consumer_principal) {
+            lines.push(`Consumer principal: ${result.consumer_principal}`);
+        }
+        lines.push("", "Open the link in your browser to view usage metrics, spend, rebates, and recent runs.");
+        return text(lines.join("\n"));
+    });
+}

package/dist/tools/rebates.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRebateTools(server: McpServer): void;

package/dist/tools/rebates.js

@@ -0,0 +1,51 @@
+import { apiGet } from "../core/api-client.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+function money(value) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? `$${numeric.toFixed(4)}` : `$${value}`;
+}
+function sourceLabel(value) {
+    return value.replace(/_/g, " ");
+}
+export function registerRebateTools(server) {
+    server.tool("rebate_status", "Show your Agent Wonderland consumer rebate balance, payout threshold, blocked rebates, and recent payout transactions.", {}, async () => {
+        const status = await apiGet("/rebates/status", { ensureConsumerPrincipal: true });
+        const threshold = Number(status.auto_payout_threshold_usd);
+        const pending = Number(status.totals.pending_usd);
+        const remaining = Math.max(0, threshold - pending);
+        const lines = [
+            "Rebate status",
+            `Consumer principal: ${status.consumer_principal}`,
+            `Base payout address: ${status.payout_address ?? "not configured"}`,
+            "",
+            `Lifetime earned: ${money(status.totals.lifetime_earned_usd)} across ${status.totals.total_count} rebate(s)`,
+            `Paid out: ${money(status.totals.paid_usd)} across ${status.totals.paid_count} rebate(s)`,
+            `Pending: ${money(status.totals.pending_usd)} across ${status.totals.pending_count} rebate(s)`,
+            `Blocked: ${money(status.totals.blocked_usd)} across ${status.totals.blocked_count} rebate(s)`,
+        ];
+        if (Number.isFinite(threshold) && threshold > 0) {
+            lines.push(pending >= threshold
+                ? `Auto payout: eligible for the next processor run (threshold ${money(threshold)})`
+                : `Auto payout: ${money(remaining)} until the ${money(threshold)} threshold`);
+        }
+        if (status.by_source.length > 0) {
+            lines.push("", "By source:");
+            for (const row of status.by_source) {
+                lines.push(`  ${sourceLabel(row.source_type)} / ${row.status}: ${money(row.rebate_usd)} (${row.count})`);
+            }
+        }
+        if (status.recent_payouts.length > 0) {
+            lines.push("", "Recent payouts:");
+            for (const payout of status.recent_payouts.slice(0, 5)) {
+                const tx = payout.tx_hash ? ` tx=${payout.tx_hash}` : "";
+                lines.push(`  ${payout.status}: ${money(payout.amount_usd)} (${payout.earning_count})${tx}`);
+            }
+        }
+        if (!status.payout_address) {
+            lines.push("", "No Base payout address is configured, so new rebates may be blocked.");
+        }
+        return text(lines.join("\n"));
+    });
+}

package/dist/tools/run.js

@@ -166,6 +166,9 @@ export function registerRunTools(server) {
                 `  Cost: $${price.toFixed(2)}`,
                 `  Payment: ${formatPaymentLabel(method)}`,
             ];
+            if (method === "link") {
+                quoteLines.push("  Link: after confirming here, approve the Link spend request and rerun the confirmed call.");
+            }
             const creditPackLines = buildCreditPackOfferLines(agent);
             if (creditPackLines.length > 0) {
                 quoteLines.push("", ...creditPackLines);
@@ -226,6 +229,9 @@ export function registerRunTools(server) {
                 ].join("\n"));
             }
             const msg = apiErr?.message ?? "Failed to run agent";
+            if (msg.includes("Link approval required.")) {
+                return text(msg);
+            }
             if (msg.includes("Missing required field") || msg.includes("validation failed")) {
                 return text(`Error: ${msg}\n\nUse get_agent("${agent_id}") to see the required input fields.`);
             }

package/dist/tools/solve.js

@@ -241,6 +241,9 @@ export function registerSolveTools(server) {
                 `Best match: ${selected.name}`,
                 `Cost: $${estimatedCost.toFixed(2)}`,
                 `Payment: ${formatPaymentLabel(method)}`,
+                ...(method === "link"
+                    ? ["Link: after confirming here, approve the Link spend request and rerun the confirmed call."]
+                    : []),
                 ...(() => {
                     const summary = buildCreditPackSummary(selected);
                     return summary.length > 0 ? ["", ...summary] : [];
@@ -298,7 +301,11 @@ export function registerSolveTools(server) {
                     })(),
                 ].join("\n"));
             }
-            return text(`Error: ${apiErr?.message ?? "Failed to run agent"}`);
+            const msg = apiErr?.message ?? "Failed to run agent";
+            if (msg.includes("Link approval required.")) {
+                return text(msg);
+            }
+            return text(`Error: ${msg}`);
         }
         pendingSolves.delete(pendingKey);
         const jobId = result.job_id ?? "";