@agentwonderland/mcp 0.1.54 → 0.1.55

package/src/core/link-cli.ts

@@ -21,6 +21,15 @@ export class LinkApprovalRequiredError extends Error {
   }
 }
 
+export interface ApprovedLinkSpendRequestParams {
+  amount: string;
+  currency: string;
+  context: string;
+  expiresAt: number;
+  networkId: string;
+  paymentMethodId: string;
+}
+
 function formatLinkApprovalRequiredMessage(spendRequestId: string, approvalUrl?: string): string {
   return [
     "Link approval required.",
@@ -137,6 +146,16 @@ function extractSpendRequestApproval(output: unknown): { id: string; approvalUrl
   return null;
 }
 
+function extractSpendRequestStatus(output: unknown): { id?: string; approvalUrl?: string; status?: string } {
+  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: PendingLinkSpendRequest | null,
   params: {
@@ -162,6 +181,14 @@ function isProjectedSpendCapError(message: string): boolean {
   return /projected daily spend|projected spend|exceeds limit/i.test(message);
 }
 
+function isApprovedSpendRequestStatus(status?: string): boolean {
+  return /approved|active|ready/i.test(status ?? "");
+}
+
+function isPendingSpendRequestStatus(status?: string): boolean {
+  return /pending/i.test(status ?? "");
+}
+
 function recordLinkCooldown(reason: string): void {
   const now = new Date();
   setLinkCooldown({
@@ -370,6 +397,168 @@ export async function createLinkSharedPaymentToken(params: {
   }
 }
 
+export async function ensureApprovedLinkSpendRequest(params: ApprovedLinkSpendRequestParams): Promise<string> {
+  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: unknown;
+  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: unknown): unknown {
+  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: {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: unknown;
+  spendRequestId: string;
+}): Promise<unknown> {
+  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: string): Promise<string> {
+  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: string, approvalUrl?: string): Promise<string> {
   const retrieved = await runLinkCli([
     "spend-request",

package/src/core/version.ts

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

package/src/index.ts

@@ -52,7 +52,7 @@ export async function startMcpServer(): Promise<void> {
         "   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/src/tools/__tests__/playbooks.test.ts

@@ -2,20 +2,38 @@ 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: string;
+  spendRequestId: string;
+
+  constructor(approvalUrl: string, 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,
 }));
 
@@ -30,6 +48,8 @@ vi.mock("../../core/payments.js", () => ({
 }));
 
 vi.mock("../../core/config.js", () => ({
+  getLinkConfig: mockGetLinkConfig,
+  setPendingLinkSpendRequest: mockSetPendingLinkSpendRequest,
   requiresSpendConfirmation: mockRequiresSpendConfirmation,
 }));
 
@@ -43,6 +63,12 @@ vi.mock("../_token-cache.js", () => ({
   storeFeedbackToken: mockStoreFeedbackToken,
 }));
 
+vi.mock("../../core/link-cli.js", () => ({
+  decodeMppNetworkId: mockDecodeMppNetworkId,
+  ensureApprovedLinkSpendRequest: mockEnsureApprovedLinkSpendRequest,
+  LinkApprovalRequiredError: MockLinkApprovalRequiredError,
+}));
+
 function flattenToolText(result: unknown): string {
   const content = (result as { content?: Array<{ type?: string; text?: string }> })?.content ?? [];
   return content
@@ -116,6 +142,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: "" });
@@ -273,51 +304,15 @@ describe("playbook MCP tools", () => {
     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 as never);
-
-    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 as never);
 
     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();
   });
 
@@ -618,16 +613,100 @@ describe("playbook MCP tools", () => {
         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: string) => {
+      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 as never);
+
+    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 () => {