@agentwonderland/mcp 0.1.51 → 0.1.53

package/dist/tools/wallet.js

@@ -6,7 +6,7 @@ import { getSettings } from "../core/settings.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks, getCardCapabilities, pollCardSetup, } from "../core/card-setup.js";
 import { getLinkCliAuthStatus, listLinkPaymentMethods, openLinkPaymentMethodAdd, startLinkCliLogin, } from "../core/link-cli.js";
 import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, listOwsWalletsByChain, installOws, platformSupportsOws, } from "../core/ows-adapter.js";
-import { ensureConsumerPrincipal, getConsumerPrincipal } from "../core/principal.js";
+import { ensureConsumerPrincipal, ensureConsumerPrincipalForMethod, getConsumerPrincipal } from "../core/principal.js";
 import { MCP_PACKAGE_VERSION } from "../core/version.js";
 function text(t) {
     return { content: [{ type: "text", text: t }] };
@@ -221,7 +221,7 @@ export function registerWalletTools(server) {
                     paymentMethodId: selected.id,
                     label: name ?? selected.label,
                 });
-                const principal = await ensureConsumerPrincipal();
+                const principal = await ensureConsumerPrincipalForMethod("link");
                 return text([
                     "Link payment method connected.",
                     `  Payment method: ${selected.label ?? selected.id}${selected.label ? ` (${selected.id})` : ""}`,
@@ -254,7 +254,7 @@ export function registerWalletTools(server) {
                     paymentMethodId: method.id,
                     label: method.label,
                 });
-                const principal = await ensureConsumerPrincipal();
+                const principal = await ensureConsumerPrincipalForMethod("link");
                 return text([
                     "Link payment method connected.",
                     `  Payment method: ${method.id}${method.label ? ` (${method.label})` : ""}`,
@@ -293,7 +293,7 @@ export function registerWalletTools(server) {
             if (pendingToken) {
                 const result = await pollCardSetup(pendingToken, 250);
                 if (result) {
-                    const principal = await ensureConsumerPrincipal();
+                    const principal = await ensureConsumerPrincipalForMethod("card");
                     return text(`Connected! ${result.brand} ****${result.last4} is ready for payments.\n\n` +
                         `Consumer principal: ${principal}`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {

package/src/core/__tests__/api-client.test.ts

@@ -1,10 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MCP_PACKAGE_VERSION } from "../version.js";
 
 const {
   mockGetApiUrl,
   mockGetApiKey,
   mockGetPaymentFetch,
   mockEnsureConsumerPrincipalForMethod,
+  mockEnsureBaseRebatePrincipal,
   mockGetConsumerPrincipalForMethod,
   mockGetBaseRebatePrincipal,
   mockPaymentFetch,
@@ -13,6 +15,7 @@ const {
   mockGetApiKey: vi.fn(),
   mockGetPaymentFetch: vi.fn(),
   mockEnsureConsumerPrincipalForMethod: vi.fn(),
+  mockEnsureBaseRebatePrincipal: vi.fn(),
   mockGetConsumerPrincipalForMethod: vi.fn(),
   mockGetBaseRebatePrincipal: vi.fn(),
   mockPaymentFetch: vi.fn(),
@@ -29,6 +32,7 @@ vi.mock("../payments.js", () => ({
 
 vi.mock("../principal.js", () => ({
   ensureConsumerPrincipal: vi.fn(),
+  ensureBaseRebatePrincipal: (...args: unknown[]) => mockEnsureBaseRebatePrincipal(...args),
   ensureConsumerPrincipalForMethod: (...args: unknown[]) => mockEnsureConsumerPrincipalForMethod(...args),
   getConsumerPrincipal: vi.fn(),
   getConsumerPrincipalForMethod: (...args: unknown[]) => mockGetConsumerPrincipalForMethod(...args),
@@ -50,6 +54,9 @@ describe("api-client headers", () => {
     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" },
@@ -72,7 +79,7 @@ describe("api-client headers", () => {
           "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/src/core/__tests__/link-cli.test.ts

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PendingLinkSpendRequest } from "../config.js";
+
+const {
+  execCalls,
+  outputs,
+  state,
+  mockExecFile,
+} = vi.hoisted(() => {
+  const execCalls: Array<{ file: string; args: string[] }> = [];
+  const outputs: unknown[] = [];
+  const state: { pending: PendingLinkSpendRequest | null; pendingWrites: Array<PendingLinkSpendRequest | null> } = {
+    pending: null,
+    pendingWrites: [],
+  };
+
+  type MockExecFile = ((file: string, args: string[], options: unknown, callback: (err: Error | null, stdout?: string, stderr?: string) => void) => void) & {
+    [key: symbol]: unknown;
+  };
+  const mockExecFile = vi.fn((file: string, args: string[], _options: unknown, callback: (err: Error | null, stdout?: string, stderr?: string) => void) => {
+    execCalls.push({ file, args });
+    const next = outputs.shift();
+    if (next instanceof Error) {
+      callback(next);
+      return;
+    }
+    callback(null, JSON.stringify(next ?? null), "");
+  }) as unknown as MockExecFile;
+  mockExecFile[Symbol.for("nodejs.util.promisify.custom")] = async (file: string, args: string[]) => {
+    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: PendingLinkSpendRequest | null) => {
+    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/src/core/__tests__/principal.test.ts

@@ -137,6 +137,22 @@ describe("consumer principal helpers", () => {
     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" },
@@ -152,4 +168,19 @@ describe("consumer principal helpers", () => {
 
     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/src/core/api-client.ts

@@ -2,7 +2,7 @@ import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
 import {
   getBaseRebatePrincipal,
-  ensureConsumerPrincipal,
+  ensureBaseRebatePrincipal,
   ensureConsumerPrincipalForMethod,
   getConsumerPrincipal,
   getConsumerPrincipalForMethod,
@@ -70,7 +70,9 @@ async function buildHeaders(path: string, method: string, options?: RequestOptio
     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/src/core/link-cli.ts

@@ -11,8 +11,23 @@ const execFileAsync = promisify(execFile);
 const LINK_CLI_PACKAGE = "@stripe/link-cli";
 const LINK_CLI_TIMEOUT_MS = 10 * 60 * 1000;
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+export class LinkApprovalRequiredError extends Error {
+  constructor(
+    public readonly spendRequestId: string,
+    public readonly approvalUrl?: string,
+  ) {
+    super(formatLinkApprovalRequiredMessage(spendRequestId, approvalUrl));
+    this.name = "LinkApprovalRequiredError";
+  }
+}
+
+function formatLinkApprovalRequiredMessage(spendRequestId: string, approvalUrl?: string): string {
+  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");
 }
 
 export interface LinkCliAuthStatus {
@@ -264,6 +279,9 @@ export async function createLinkSharedPaymentToken(params: {
       return spt;
     } 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;
       }
@@ -344,9 +362,7 @@ 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);
   }
 
   {
@@ -355,32 +371,14 @@ export async function createLinkSharedPaymentToken(params: {
 }
 
 async function retrieveSharedPaymentToken(spendRequestId: string, approvalUrl?: string): Promise<string> {
-  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/src/core/principal.ts

@@ -80,6 +80,43 @@ async function createFallbackIdentityWallet(): Promise<WalletEntry> {
   return entry;
 }
 
+async function ensureEvmIdentityWallet(): Promise<WalletEntry> {
+  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: WalletEntry = {
+        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: WalletEntry = {
+      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(): Promise<WalletEntry> {
   const wallets = preferredWallets();
   const existing = wallets.find((wallet) => walletSupportsEvm(wallet) || walletSupportsSolana(wallet));
@@ -131,9 +168,21 @@ export async function getBaseRebatePrincipal(): Promise<string | null> {
   return (await principalForChain("base")) ?? principalForChain("tempo");
 }
 
+export async function ensureBaseRebatePrincipal(): Promise<string> {
+  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?: string): Promise<string | null> {
   if (!method || method === "card" || method === "link") {
-    return getConsumerPrincipal();
+    return getBaseRebatePrincipal();
   }
 
   const resolved = resolveWalletAndChain(method);
@@ -158,6 +207,10 @@ export async function ensureConsumerPrincipalForMethod(method?: string): Promise
   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}". ` +

package/src/index.ts

@@ -14,6 +14,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";
@@ -71,6 +72,7 @@ export async function startMcpServer(): Promise<void> {
         "",
         "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.",
@@ -89,6 +91,7 @@ export async function startMcpServer(): Promise<void> {
   registerFavoriteTools(server);
   registerTipTools(server);
   registerPassTools(server);
+  registerRebateTools(server);
   registerUploadTools(server);
   registerProbeTools(server);
   registerProviderTools(server);

package/src/tools/__tests__/rebates.test.ts

@@ -0,0 +1,91 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type ToolResult = {
+  content: Array<{ type: "text"; text: string }>;
+};
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock("../../core/api-client.js", () => ({
+  apiGet: (...args: unknown[]) => mockApiGet(...args),
+}));
+
+async function getRebateStatusTool(): Promise<(args: Record<string, unknown>) => Promise<ToolResult>> {
+  const tools = new Map<string, (args: Record<string, unknown>) => Promise<ToolResult>>();
+  const server = {
+    tool: (
+      name: string,
+      _description: string,
+      _schema: unknown,
+      handler: (args: Record<string, unknown>) => Promise<ToolResult>,
+    ) => {
+      tools.set(name, handler);
+    },
+  } as unknown as McpServer;
+
+  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: ToolResult): string {
+  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/src/tools/__tests__/run.test.ts

@@ -173,4 +173,37 @@ 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 as never);
+
+    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/src/tools/__tests__/wallet.test.ts

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

package/src/tools/index.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";