@agentwonderland/mcp 0.1.54 → 0.1.55

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

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { MCP_PACKAGE_VERSION } from "../version.js";
-const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPrincipalForMethod, mockEnsureBaseRebatePrincipal, mockGetConsumerPrincipalForMethod, mockGetBaseRebatePrincipal, mockPaymentFetch, } = vi.hoisted(() => ({
+const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPrincipalForMethod, mockEnsureBaseRebatePrincipal, mockGetConsumerPrincipalForMethod, mockGetBaseRebatePrincipal, mockPaymentFetch, mockPayMppWithApprovedLinkSpendRequest, } = vi.hoisted(() => ({
     mockGetApiUrl: vi.fn(),
     mockGetApiKey: vi.fn(),
     mockGetPaymentFetch: vi.fn(),
@@ -9,6 +9,7 @@ const { mockGetApiUrl, mockGetApiKey, mockGetPaymentFetch, mockEnsureConsumerPri
     mockGetConsumerPrincipalForMethod: vi.fn(),
     mockGetBaseRebatePrincipal: vi.fn(),
     mockPaymentFetch: vi.fn(),
+    mockPayMppWithApprovedLinkSpendRequest: vi.fn(),
 }));
 vi.mock("../config.js", () => ({
     getApiUrl: () => mockGetApiUrl(),
@@ -25,6 +26,9 @@ vi.mock("../principal.js", () => ({
     getConsumerPrincipalForMethod: (...args) => mockGetConsumerPrincipalForMethod(...args),
     getBaseRebatePrincipal: (...args) => mockGetBaseRebatePrincipal(...args),
 }));
+vi.mock("../link-cli.js", () => ({
+    payMppWithApprovedLinkSpendRequest: (...args) => mockPayMppWithApprovedLinkSpendRequest(...args),
+}));
 describe("api-client headers", () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -39,6 +43,7 @@ describe("api-client headers", () => {
             status: 200,
             headers: { "content-type": "application/json" },
         }));
+        mockPayMppWithApprovedLinkSpendRequest.mockResolvedValue({ ok: true });
     });
     it("includes the Base rebate principal alongside the method-specific consumer principal", async () => {
         const { apiPostWithPayment } = await import("../api-client.js");
@@ -96,4 +101,23 @@ describe("api-client headers", () => {
         expect(calls[8]).toMatchObject({ url: "/playbook-runs/run-1", headers: { "X-AW-MCP-Tool": "run_playbook", "X-AW-MCP-Action": "poll" } });
         expect(calls[9]).toMatchObject({ url: "/playbook-runs/run-1/steps/ads", headers: { "X-AW-MCP-Tool": "run_playbook", "X-AW-MCP-Action": "execute" } });
     });
+    it("uses Link MPP pay with run-agent headers for an approved spend request", async () => {
+        const { apiPostWithApprovedLinkSpendRequest } = await import("../api-client.js");
+        await apiPostWithApprovedLinkSpendRequest("/agents/agent-1/run", { input: { text: "hello" } }, "lsrq_test_123");
+        expect(mockPayMppWithApprovedLinkSpendRequest).toHaveBeenCalledWith(expect.objectContaining({
+            url: "https://api.agentwonderland.test/agents/agent-1/run",
+            method: "POST",
+            body: { input: { text: "hello" } },
+            spendRequestId: "lsrq_test_123",
+            headers: expect.objectContaining({
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                "X-AW-Surface": "mcp",
+                "X-AW-MCP-Version": MCP_PACKAGE_VERSION,
+                "X-AW-MCP-Tool": "run_agent",
+                "X-AW-MCP-Action": "execute",
+            }),
+        }));
+        expect(mockEnsureConsumerPrincipalForMethod).toHaveBeenCalledWith("link");
+    });
 });

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

@@ -99,4 +99,99 @@ describe("Link CLI spend requests", () => {
         expect(execCalls[0]?.args).toEqual(expect.arrayContaining(["spend-request", "retrieve", "lsrq_test_123"]));
         expect(state.pendingWrites).toEqual([null]);
     });
+    it("reuses an approved spend request id for playbook MPP payments", async () => {
+        const expiresAt = Math.floor(Date.now() / 1000) + 300;
+        state.pending = {
+            id: "lsrq_test_123",
+            approvalUrl: "https://link.example/approve/lsrq_test_123",
+            amount: "500",
+            currency: "usd",
+            context: "Agent Wonderland playbook test context that is long enough for Link",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+            createdAt: new Date().toISOString(),
+        };
+        outputs.push({ id: "lsrq_test_123", status: "approved" });
+        const { ensureApprovedLinkSpendRequest } = await import("../link-cli.js");
+        await expect(ensureApprovedLinkSpendRequest({
+            amount: "500",
+            currency: "usd",
+            context: "Agent Wonderland playbook test context that is long enough for Link",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        })).resolves.toBe("lsrq_test_123");
+        expect(execCalls).toHaveLength(1);
+        expect(execCalls[0]?.args).toEqual(expect.arrayContaining(["spend-request", "retrieve", "lsrq_test_123"]));
+        expect(state.pendingWrites).toEqual([]);
+    });
+    it("pauses when the reusable Link spend request is still pending approval", async () => {
+        const expiresAt = Math.floor(Date.now() / 1000) + 300;
+        state.pending = {
+            id: "lsrq_test_123",
+            approvalUrl: "https://link.example/approve/lsrq_test_123",
+            amount: "500",
+            currency: "usd",
+            context: "Agent Wonderland playbook test context that is long enough for Link",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+            createdAt: new Date().toISOString(),
+        };
+        outputs.push({ id: "lsrq_test_123", status: "pending_approval" });
+        const { ensureApprovedLinkSpendRequest, LinkApprovalRequiredError } = await import("../link-cli.js");
+        await expect(ensureApprovedLinkSpendRequest({
+            amount: "500",
+            currency: "usd",
+            context: "Agent Wonderland playbook test context that is long enough for Link",
+            expiresAt,
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        })).rejects.toBeInstanceOf(LinkApprovalRequiredError);
+        expect(execCalls).toHaveLength(1);
+        expect(state.pendingWrites).toEqual([]);
+    });
+    it("runs Link MPP pay with an approved spend request and returns the response body", async () => {
+        outputs.push({
+            response: {
+                body: {
+                    status: "success",
+                    job_id: "job_123",
+                },
+            },
+        });
+        const { payMppWithApprovedLinkSpendRequest } = await import("../link-cli.js");
+        await expect(payMppWithApprovedLinkSpendRequest({
+            url: "https://api.agentwonderland.test/agents/agent-1/run",
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: { input: { text: "hello" } },
+            spendRequestId: "lsrq_test_123",
+        })).resolves.toEqual({
+            status: "success",
+            job_id: "job_123",
+        });
+        expect(execCalls[0]?.args).toEqual(expect.arrayContaining([
+            "mpp",
+            "pay",
+            "https://api.agentwonderland.test/agents/agent-1/run",
+            "--spend-request-id",
+            "lsrq_test_123",
+            "--method",
+            "POST",
+            "--data",
+            JSON.stringify({ input: { text: "hello" } }),
+        ]));
+        expect(execCalls[0]?.args).toContain("Accept: application/json");
+    });
+    it("decodes the MPP network id from a payment challenge", async () => {
+        outputs.push({ accepts: [{ network_id: "profile_test" }] });
+        const { decodeMppNetworkId } = await import("../link-cli.js");
+        await expect(decodeMppNetworkId("Payment challenge")).resolves.toBe("profile_test");
+        expect(execCalls[0]?.args).toEqual(expect.arrayContaining(["mpp", "decode", "--challenge", "Payment challenge"]));
+    });
 });

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

@@ -1,7 +1,8 @@
 export declare class ApiError extends Error {
     readonly status: number;
     readonly body?: unknown | undefined;
-    constructor(status: number, message: string, body?: unknown | undefined);
+    readonly headers?: Headers | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined, headers?: Headers | undefined);
 }
 interface RequestOptions {
     ensureConsumerPrincipal?: boolean;
@@ -16,5 +17,6 @@ export declare function apiPost<T>(path: string, body: unknown, options?: Reques
  * Pass `payWith` to specify a method, or omit for auto-detection.
  */
 export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string, options?: RequestOptions): Promise<T>;
+export declare function apiPostWithApprovedLinkSpendRequest<T>(path: string, body: unknown, spendRequestId: string, options?: RequestOptions): Promise<T>;
 export declare function apiPut<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
 export {};

package/dist/core/api-client.js

@@ -2,14 +2,17 @@ import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
 import { getBaseRebatePrincipal, ensureBaseRebatePrincipal, ensureConsumerPrincipalForMethod, getConsumerPrincipalForMethod, } from "./principal.js";
 import { MCP_PACKAGE_VERSION } from "./version.js";
+import { payMppWithApprovedLinkSpendRequest } from "./link-cli.js";
 // ── Error class ────────────────────────────────────────────────────
 export class ApiError extends Error {
     status;
     body;
-    constructor(status, message, body) {
+    headers;
+    constructor(status, message, body, headers) {
         super(message);
         this.status = status;
         this.body = body;
+        this.headers = headers;
         this.name = "ApiError";
     }
 }
@@ -96,7 +99,7 @@ async function handleResponse(response) {
                 : typeof body === "string"
                     ? body
                     : `Request failed with status ${response.status}`;
-        throw new ApiError(response.status, message, body);
+        throw new ApiError(response.status, message, body, response.headers);
     }
     return body;
 }
@@ -163,6 +166,22 @@ export async function apiPostWithPayment(path, body, payWith, options) {
     const result = await handleResponse(response);
     return attachResponseMetadata(result, response);
 }
+export async function apiPostWithApprovedLinkSpendRequest(path, body, spendRequestId, options) {
+    const url = `${getApiUrl()}${path}`;
+    const headers = await buildHeaders(path, "POST", {
+        ensureConsumerPrincipal: true,
+        principalMethod: "link",
+        ...options,
+    });
+    const result = await payMppWithApprovedLinkSpendRequest({
+        url,
+        method: "POST",
+        headers,
+        body,
+        spendRequestId,
+    });
+    return result;
+}
 export async function apiPut(path, body, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {

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

@@ -3,6 +3,14 @@ export declare class LinkApprovalRequiredError extends Error {
     readonly approvalUrl?: string | undefined;
     constructor(spendRequestId: string, approvalUrl?: string | undefined);
 }
+export interface ApprovedLinkSpendRequestParams {
+    amount: string;
+    currency: string;
+    context: string;
+    expiresAt: number;
+    networkId: string;
+    paymentMethodId: string;
+}
 export interface LinkCliAuthStatus {
     authenticated: boolean;
     credentialsPath?: string;
@@ -30,3 +38,12 @@ export declare function createLinkSharedPaymentToken(params: {
     networkId: string;
     paymentMethodId: string;
 }): Promise<string>;
+export declare function ensureApprovedLinkSpendRequest(params: ApprovedLinkSpendRequestParams): Promise<string>;
+export declare function payMppWithApprovedLinkSpendRequest(params: {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    spendRequestId: string;
+}): Promise<unknown>;
+export declare function decodeMppNetworkId(challenge: string): Promise<string>;

package/dist/core/link-cli.js

@@ -108,6 +108,16 @@ function extractSpendRequestApproval(output) {
     }
     return null;
 }
+function extractSpendRequestStatus(output) {
+    const record = Array.isArray(output) ? asRecord(output[0]) : asRecord(output);
+    if (!record)
+        return {};
+    return {
+        id: typeof record.id === "string" ? record.id : undefined,
+        approvalUrl: typeof record.approval_url === "string" ? record.approval_url : undefined,
+        status: typeof record.status === "string" ? record.status : undefined,
+    };
+}
 function isMatchingPendingSpendRequest(pending, params) {
     if (!pending)
         return false;
@@ -128,6 +138,12 @@ function isMatchingPendingSpendRequest(pending, params) {
 function isProjectedSpendCapError(message) {
     return /projected daily spend|projected spend|exceeds limit/i.test(message);
 }
+function isApprovedSpendRequestStatus(status) {
+    return /approved|active|ready/i.test(status ?? "");
+}
+function isPendingSpendRequestStatus(status) {
+    return /pending/i.test(status ?? "");
+}
 function recordLinkCooldown(reason) {
     const now = new Date();
     setLinkCooldown({
@@ -317,6 +333,155 @@ export async function createLinkSharedPaymentToken(params) {
         throw new Error("Link spend request completed without a shared payment token in the CLI response.");
     }
 }
+export async function ensureApprovedLinkSpendRequest(params) {
+    const existing = getPendingLinkSpendRequest();
+    if (isMatchingPendingSpendRequest(existing, params)) {
+        const retrieved = await runLinkCli([
+            "spend-request",
+            "retrieve",
+            existing.id,
+        ], 30_000);
+        const status = extractSpendRequestStatus(retrieved);
+        if (isApprovedSpendRequestStatus(status.status)) {
+            return existing.id;
+        }
+        if (isPendingSpendRequestStatus(status.status)) {
+            throw new LinkApprovalRequiredError(existing.id, existing.approvalUrl ?? status.approvalUrl);
+        }
+        setPendingLinkSpendRequest(null);
+    }
+    const args = [
+        "spend-request",
+        "create",
+        "--credential-type",
+        "shared_payment_token",
+        "--network-id",
+        params.networkId,
+        "--amount",
+        params.amount,
+        "--currency",
+        params.currency,
+        "--payment-method-id",
+        params.paymentMethodId,
+        "--context",
+        params.context,
+        "--request-approval",
+    ];
+    if (process.env.AGENTWONDERLAND_LINK_TEST_MODE === "1") {
+        args.push("--test");
+    }
+    let output;
+    try {
+        output = await runLinkCli(args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (isProjectedSpendCapError(message)) {
+            recordLinkCooldown(message);
+            throw new Error([
+                "Link is temporarily blocked by Stripe's projected-spend cap.",
+                "Reauthing Link or switching cards in the same Link account will not fix this.",
+                "Use USDC for now, wait for the rolling Link window to clear, or ask Stripe to raise/clear the merchant projected-spend cap.",
+                "",
+                message,
+            ].join("\n"));
+        }
+        throw err;
+    }
+    const status = extractSpendRequestStatus(output);
+    const id = status.id ?? extractSpendRequestApproval(output)?.id;
+    if (id && isApprovedSpendRequestStatus(status.status)) {
+        setPendingLinkSpendRequest({
+            id,
+            approvalUrl: status.approvalUrl,
+            amount: params.amount,
+            currency: params.currency,
+            context: params.context,
+            expiresAt: params.expiresAt,
+            networkId: params.networkId,
+            paymentMethodId: params.paymentMethodId,
+            createdAt: new Date().toISOString(),
+        });
+        return id;
+    }
+    const approval = extractSpendRequestApproval(output);
+    if (approval?.id && isPendingSpendRequestStatus(approval.status)) {
+        setPendingLinkSpendRequest({
+            id: approval.id,
+            approvalUrl: approval.approvalUrl,
+            amount: params.amount,
+            currency: params.currency,
+            context: params.context,
+            expiresAt: params.expiresAt,
+            networkId: params.networkId,
+            paymentMethodId: params.paymentMethodId,
+            createdAt: new Date().toISOString(),
+        });
+        if (approval.approvalUrl) {
+            console.error(`Link approval required: ${approval.approvalUrl}`);
+        }
+        throw new LinkApprovalRequiredError(approval.id, approval.approvalUrl);
+    }
+    throw new Error("Link spend request did not return an approved or pending approval state.");
+}
+function extractMppPayBody(output) {
+    if (typeof output === "string") {
+        try {
+            return JSON.parse(output);
+        }
+        catch {
+            return output;
+        }
+    }
+    if (Array.isArray(output)) {
+        return output.length === 1 ? extractMppPayBody(output[0]) : output;
+    }
+    const record = asRecord(output);
+    if (!record)
+        return output;
+    for (const key of ["body", "json", "data", "response_body"]) {
+        const value = record[key];
+        if (value !== undefined)
+            return extractMppPayBody(value);
+    }
+    const response = asRecord(record.response);
+    if (response)
+        return extractMppPayBody(response.body ?? response.json ?? response.data ?? response);
+    return output;
+}
+export async function payMppWithApprovedLinkSpendRequest(params) {
+    const args = [
+        "mpp",
+        "pay",
+        params.url,
+        "--spend-request-id",
+        params.spendRequestId,
+        "--method",
+        params.method,
+    ];
+    for (const [name, value] of Object.entries(params.headers)) {
+        args.push("--header", `${name}: ${value}`);
+    }
+    if (params.body !== undefined) {
+        args.push("--data", typeof params.body === "string" ? params.body : JSON.stringify(params.body));
+    }
+    const output = await runLinkCli(args);
+    return extractMppPayBody(output);
+}
+export async function decodeMppNetworkId(challenge) {
+    const output = await runLinkCli(["mpp", "decode", "--challenge", challenge], 30_000);
+    const found = walk(output, (value, key) => {
+        if (typeof value !== "string")
+            return null;
+        if (key && /network[_-]?id/i.test(key))
+            return value;
+        return null;
+    });
+    if (!found) {
+        throw new Error("Could not decode Link MPP network_id from payment challenge.");
+    }
+    return found;
+}
 async function retrieveSharedPaymentToken(spendRequestId, approvalUrl) {
     const retrieved = await runLinkCli([
         "spend-request",

package/dist/core/version.d.ts

@@ -1 +1 @@
-export declare const MCP_PACKAGE_VERSION = "0.1.54";
+export declare const MCP_PACKAGE_VERSION = "0.1.55";

package/dist/core/version.js

@@ -1 +1 @@
-export const MCP_PACKAGE_VERSION = "0.1.54";
+export const MCP_PACKAGE_VERSION = "0.1.55";

package/dist/index.js

@@ -45,7 +45,7 @@ export async function startMcpServer() {
             "   For multi-agent workflows, use search_playbooks() → get_playbook() → run_playbook().",
             "2. If the agent returns status 'processing', poll with get_job(). Async runs resolve automatically.",
             "3. After a successful agent run, rate_agent() and optionally tip_agent() if the result was useful.",
-            "   After a successful playbook run, offer favorite_playbook() or rate_playbook() using the returned run_id.",
+            "   Playbooks return one run-level receipt; do not ask users to rate or tip individual child-agent steps.",
             "4. Use list_jobs() to recover state across sessions (it checks every configured wallet).",
             "",
             "PAYMENT:",

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

@@ -1,19 +1,35 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 const mockApiGet = vi.fn();
 const mockApiPost = vi.fn();
+const mockApiPostWithApprovedLinkSpendRequest = vi.fn();
 const mockApiPostWithPayment = vi.fn();
 const mockUploadLocalFiles = vi.fn();
 const mockHasWalletConfigured = vi.fn();
 const mockGetConfiguredMethods = vi.fn();
 const mockGetWalletAddress = vi.fn();
+const mockGetLinkConfig = vi.fn();
+const mockSetPendingLinkSpendRequest = vi.fn();
 const mockRequiresSpendConfirmation = vi.fn();
 const mockCanSpend = vi.fn();
 const mockRecordSpend = vi.fn();
 const mockRequiresPolicyConfirmation = vi.fn();
 const mockStoreFeedbackToken = vi.fn();
+const mockDecodeMppNetworkId = vi.fn();
+const mockEnsureApprovedLinkSpendRequest = vi.fn();
+class MockLinkApprovalRequiredError extends Error {
+    approvalUrl;
+    spendRequestId;
+    constructor(approvalUrl, spendRequestId = "lsrq_test_123") {
+        super(`Link approval required: ${approvalUrl}`);
+        this.name = "LinkApprovalRequiredError";
+        this.approvalUrl = approvalUrl;
+        this.spendRequestId = spendRequestId;
+    }
+}
 vi.mock("../../core/api-client.js", () => ({
     apiGet: mockApiGet,
     apiPost: mockApiPost,
+    apiPostWithApprovedLinkSpendRequest: mockApiPostWithApprovedLinkSpendRequest,
     apiPostWithPayment: mockApiPostWithPayment,
 }));
 vi.mock("../../core/file-upload.js", () => ({
@@ -25,6 +41,8 @@ vi.mock("../../core/payments.js", () => ({
     getWalletAddress: mockGetWalletAddress,
 }));
 vi.mock("../../core/config.js", () => ({
+    getLinkConfig: mockGetLinkConfig,
+    setPendingLinkSpendRequest: mockSetPendingLinkSpendRequest,
     requiresSpendConfirmation: mockRequiresSpendConfirmation,
 }));
 vi.mock("../../core/spend-policy.js", () => ({
@@ -35,6 +53,11 @@ vi.mock("../../core/spend-policy.js", () => ({
 vi.mock("../_token-cache.js", () => ({
     storeFeedbackToken: mockStoreFeedbackToken,
 }));
+vi.mock("../../core/link-cli.js", () => ({
+    decodeMppNetworkId: mockDecodeMppNetworkId,
+    ensureApprovedLinkSpendRequest: mockEnsureApprovedLinkSpendRequest,
+    LinkApprovalRequiredError: MockLinkApprovalRequiredError,
+}));
 function flattenToolText(result) {
     const content = result?.content ?? [];
     return content
@@ -105,6 +128,11 @@ describe("playbook MCP tools", () => {
         mockHasWalletConfigured.mockReturnValue(true);
         mockGetConfiguredMethods.mockReturnValue(["card"]);
         mockGetWalletAddress.mockResolvedValue("0xabc");
+        mockGetLinkConfig.mockReturnValue({
+            paymentMethodId: "csmrpd_test_123",
+        });
+        mockDecodeMppNetworkId.mockResolvedValue("profile_test");
+        mockEnsureApprovedLinkSpendRequest.mockResolvedValue("lsrq_test_123");
         mockRequiresSpendConfirmation.mockReturnValue(true);
         mockRequiresPolicyConfirmation.mockReturnValue(false);
         mockCanSpend.mockReturnValue({ ok: true, message: "" });
@@ -229,41 +257,13 @@ describe("playbook MCP tools", () => {
         expect(mockApiPost).toHaveBeenCalledWith("/playbooks/competitor-ads/favorite", {}, { ensureConsumerPrincipal: true });
         expect(text).toContain("Saved competitor-ads to favorites");
     });
-    it("records playbook feedback with consumer principal headers", async () => {
-        mockApiPost.mockResolvedValueOnce({
-            ok: true,
-            feedback_id: "feedback-row-1",
-            playbook_slug: "competitor-ads",
-        });
-        const { registerPlaybookTools } = await import("../playbooks.js");
-        const harness = makeServerHarness();
-        registerPlaybookTools(harness.server);
-        const result = await harness.handlers.get("rate_playbook")({
-            slug: "competitor-ads",
-            run_id: "22222222-2222-4222-8222-222222222222",
-            rating: 5,
-            useful: true,
-            comment: "Useful.",
-        });
-        const text = flattenToolText(result);
-        expect(mockApiPost).toHaveBeenCalledWith("/playbooks/competitor-ads/feedback", {
-            run_id: "22222222-2222-4222-8222-222222222222",
-            rating: 5,
-            useful: true,
-            comment: "Useful.",
-        }, { ensureConsumerPrincipal: true });
-        expect(text).toContain("Recorded feedback for competitor-ads");
-    });
-    it("validates favorite and feedback inputs before calling the gateway", async () => {
+    it("does not expose per-playbook feedback as an MCP tool", async () => {
         const { registerPlaybookTools } = await import("../playbooks.js");
         const harness = makeServerHarness();
         registerPlaybookTools(harness.server);
         const favoriteResult = await harness.handlers.get("favorite_playbook")({});
-        const emptyFeedbackResult = await harness.handlers.get("rate_playbook")({ slug: "competitor-ads" });
-        const missingIdFeedbackResult = await harness.handlers.get("rate_playbook")({ rating: 5 });
         expect(flattenToolText(favoriteResult)).toContain("Provide slug or playbook_id.");
-        expect(flattenToolText(emptyFeedbackResult)).toContain("Provide rating, useful, or comment.");
-        expect(flattenToolText(missingIdFeedbackResult)).toContain("Provide slug or playbook_id.");
+        expect(harness.handlers.has("rate_playbook")).toBe(false);
         expect(mockApiPost).not.toHaveBeenCalled();
     });
     it("quotes before confirmed execution", async () => {
@@ -526,12 +526,92 @@ describe("playbook MCP tools", () => {
             error_code: null,
             failure_message: null,
         }));
-        expect(mockStoreFeedbackToken).toHaveBeenCalledWith("33333333-3333-4333-8333-333333333333", "token", "11111111-1111-4111-8111-111111111111");
+        expect(mockStoreFeedbackToken).not.toHaveBeenCalled();
         expect(text).toContain("Playbook run 22222222-2222-4222-8222-222222222222");
         expect(text).toContain("Charged: $1.25");
-        expect(text).toContain("Was this playbook useful?");
-        expect(text).toContain("favorite_playbook({ slug: \"competitor-ads\" })");
-        expect(text).toContain("rate_playbook({ slug: \"competitor-ads\", run_id: \"22222222-2222-4222-8222-222222222222\"");
+        expect(text).not.toContain("Was this playbook useful?");
+        expect(text).not.toContain("favorite_playbook({ slug: \"competitor-ads\" })");
+        expect(text).not.toContain("rate_playbook");
+    });
+    it("uses one approved Link spend request across paid playbook child steps", async () => {
+        mockRequiresSpendConfirmation.mockReturnValue(false);
+        mockGetConfiguredMethods.mockReturnValue(["link"]);
+        mockApiGet
+            .mockResolvedValueOnce(playbook)
+            .mockResolvedValueOnce({
+            run_id: "22222222-2222-4222-8222-222222222222",
+            status: "completed",
+            playbook_id: playbook.id,
+            playbook_slug: playbook.slug,
+            playbook_version: 1,
+            budget_usd: 5,
+            quoted_cost_usd: 1.25,
+            charged_usd: 1.25,
+            refunded_usd: 0,
+            remaining_budget_usd: 3.75,
+            steps: [{
+                    playbook_step_id: "ads",
+                    step_index: 0,
+                    node_type: "aw_agent",
+                    agent_slug: "ad-strategy-intel",
+                    agent_id: "11111111-1111-4111-8111-111111111111",
+                    provider_id: null,
+                    job_id: "33333333-3333-4333-8333-333333333333",
+                    status: "succeeded",
+                    quoted_cost_usd: 1.25,
+                    charged_usd: 1.25,
+                    refunded_usd: 0,
+                }],
+        });
+        mockApiPost.mockImplementation(async (path) => {
+            if (path === "/playbook-runs") {
+                return {
+                    run_id: "22222222-2222-4222-8222-222222222222",
+                    steps: playbook.current_quote.steps,
+                };
+            }
+            if (path === "/agents/11111111-1111-4111-8111-111111111111/run") {
+                throw {
+                    status: 402,
+                    message: "payment required",
+                    headers: new Headers({ "www-authenticate": "Payment challenge" }),
+                };
+            }
+            return { ok: true };
+        });
+        mockApiPostWithApprovedLinkSpendRequest.mockResolvedValueOnce({
+            status: "success",
+            job_id: "33333333-3333-4333-8333-333333333333",
+            agent_id: "11111111-1111-4111-8111-111111111111",
+            output: { rows: 3 },
+            cost: 1.25,
+        });
+        const { registerPlaybookTools } = await import("../playbooks.js");
+        const harness = makeServerHarness();
+        registerPlaybookTools(harness.server);
+        const result = await harness.handlers.get("run_playbook")({
+            slug: "competitor-ads",
+            input: { domain: "notion.so" },
+            budget: 5,
+            pay_with: "link",
+            confirmed: true,
+        });
+        const text = flattenToolText(result);
+        expect(mockDecodeMppNetworkId).toHaveBeenCalledWith("Payment challenge");
+        expect(mockEnsureApprovedLinkSpendRequest).toHaveBeenCalledWith(expect.objectContaining({
+            amount: "500",
+            currency: "usd",
+            networkId: "profile_test",
+            paymentMethodId: "csmrpd_test_123",
+        }));
+        expect(mockApiPostWithApprovedLinkSpendRequest).toHaveBeenCalledWith("/agents/11111111-1111-4111-8111-111111111111/run", expect.objectContaining({
+            input: expect.objectContaining({
+                startUrls: [{ url: "https://notion.so" }],
+            }),
+        }), "lsrq_test_123");
+        expect(mockApiPostWithPayment).not.toHaveBeenCalled();
+        expect(mockSetPendingLinkSpendRequest).toHaveBeenCalledWith(null);
+        expect(text).toContain("Playbook run 22222222-2222-4222-8222-222222222222");
     });
     it("uploads local file inputs before run creation and child execution", async () => {
         mockRequiresSpendConfirmation.mockReturnValue(false);