@agentwonderland/mcp 0.1.52 → 0.1.53

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/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/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/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 ?? "";

package/package.json

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

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/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/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/run.ts

@@ -220,6 +220,10 @@ export function registerRunTools(server: McpServer): void {
           `  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);
@@ -299,6 +303,9 @@ export function registerRunTools(server: McpServer): void {
           );
         }
         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/src/tools/solve.ts

@@ -292,6 +292,9 @@ export function registerSolveTools(server: McpServer): void {
           `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] : [];
@@ -361,7 +364,11 @@ export function registerSolveTools(server: McpServer): void {
             ].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);