@agentpickup/mcp 0.0.0-stage → 0.1.0

package/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 Dave Hallett
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# @agentpickup/mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An MCP server for [agentPickup](https://github.com/dav3trad3r/agentpickup) shops. It lets an AI agent see
+what a shop sells, order it, pay in USDC over x402, and hand its user the QR they show at the counter to
+collect.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `get_shop` | Items and prices, the pickup location, and how the shop takes payment |
+| `create_pickup_order` | Creates an order. Needs the user's email, where the shop sends the pickup QR |
+| `pay_order` | Pays the order's x402 link from your wallet and returns the pass link. With no wallet set up, returns the price and pay link instead |
+| `order_status` | Waiting for payment, paid, ready, collected or expired |
+| `get_pickup_pass` | Fetches the pass link, pickup code and QR again by signing in as the paying wallet (Sign-In-With-X) |
+
+## Use it
+
+Try it against the hosted demo shop first. It pays with the demo's own wallet in Base Sepolia test USDC:
+
+```json
+{ "mcpServers": { "agentpickup": { "type": "http", "url": "https://web-production-3cfc1.up.railway.app/mcp" } } }
+```
+
+Or run it locally against any agentPickup shop, with your own wallet:
+
+```json
+{
+  "mcpServers": {
+    "agentpickup": {
+      "command": "npx",
+      "args": ["-y", "@agentpickup/mcp"],
+      "env": {
+        "AGENTPICKUP_SHOP_URL": "https://orders.yourshop.com",
+        "AGENTPICKUP_WALLET_KEY": "0x…",
+        "AGENTPICKUP_MAX_PER_ORDER": "$25"
+      }
+    }
+  }
+}
+```
+
+| Setting | Default | |
+|---|---|---|
+| `AGENTPICKUP_SHOP_URL` | the demo shop | The shop to order from. Tool calls can also name another shop with `shop_url` |
+| `AGENTPICKUP_WALLET_KEY` | none | An EVM private key holding USDC. Without it, `pay_order` only quotes |
+| `AGENTPICKUP_MAX_PER_ORDER` | `$25` | The most the wallet pays for one order |
+| `AGENTPICKUP_NETWORKS` | `eip155:84532` | Networks the wallet may pay on. Base Sepolia (test USDC) unless you add `eip155:8453` for Base mainnet |
+
+Use a wallet that holds only what you're willing to let an agent spend. The tools tell the model to confirm
+items and the total with the user before paying.
+
+## Host it in your own server
+
+```ts
+import { createMcpHandler, walletPayer } from "@agentpickup/mcp";
+
+const mcp = createMcpHandler({ shopUrl: "https://orders.yourshop.com" }); // no wallet: pay_order quotes
+app.all("/mcp", (c) => mcp(c.req.raw)); // Streamable HTTP, stateless, any Request/Response runtime
+```
+
+Node 22.13 or later. Licence: FSL-1.1-ALv2 (free to use and self-host; becomes Apache-2.0 two years after
+each release).

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// stdio entry: `npx @agentpickup/mcp`. Logs go to stderr; stdout belongs to the protocol.
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createPickupMcpServer } from "./server.js";
+import { walletPayer } from "./wallet.js";
+const env = process.env;
+const shopUrl = env.AGENTPICKUP_SHOP_URL || "https://web-production-3cfc1.up.railway.app";
+const key = env.AGENTPICKUP_WALLET_KEY?.trim();
+if (key && !/^0x[0-9a-fA-F]{64}$/.test(key)) {
+    console.error("AGENTPICKUP_WALLET_KEY must be a 0x-prefixed 32-byte hex private key.");
+    process.exit(1);
+}
+const payer = key
+    ? walletPayer({
+        privateKey: key,
+        maxPerOrder: env.AGENTPICKUP_MAX_PER_ORDER || undefined,
+        networks: env.AGENTPICKUP_NETWORKS?.split(",").map((n) => n.trim()).filter(Boolean),
+    })
+    : undefined;
+const server = createPickupMcpServer({ shopUrl, allowOtherShops: true, payer });
+await server.connect(new StdioServerTransport());
+console.error(`agentPickup MCP · shop ${shopUrl} · ${payer ? `wallet ${payer.address}` : "no wallet (pay_order returns the pay link)"}`);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createMcpHandler, createPickupMcpServer, VERSION, type PickupMcpOptions } from "./server.js";
+export { walletPayer, type Fetch, type Payer, type PayOutcome, type WalletPayerOptions } from "./wallet.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createMcpHandler, createPickupMcpServer, VERSION } from "./server.js";
+export { walletPayer } from "./wallet.js";

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Fetch, type Payer } from "./wallet.js";
+export declare const VERSION = "0.1.0";
+export interface PickupMcpOptions {
+    /** The agentPickup shop this server orders from. */
+    shopUrl: string;
+    /** Let tool calls name another agentPickup shop. Leave off for hosted servers, so callers can't point it anywhere. */
+    allowOtherShops?: boolean;
+    /** How requests reach the shop. Defaults to global fetch; a shop hosting its own server passes its app's fetch. */
+    fetch?: Fetch;
+    /** The wallet that pays. Without one, pay_order returns the price and pay link for another x402 client. */
+    payer?: Payer;
+}
+export declare function createPickupMcpServer(opts: PickupMcpOptions): McpServer;
+/** A Streamable HTTP endpoint (stateless, JSON responses) for hosting the server, e.g. at /mcp. */
+export declare function createMcpHandler(opts: PickupMcpOptions): (req: Request) => Promise<Response>;

package/dist/server.js

@@ -0,0 +1,179 @@
+// The agentPickup MCP server: lets any MCP client (Claude, ChatGPT, Cursor, an agent framework) find what a
+// pickup shop sells, order it, pay over x402, and hand its user the QR to collect with.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { z } from "zod";
+import { errorOf, usd } from "./wallet.js";
+export const VERSION = "0.1.0";
+class ToolError extends Error {
+}
+const INSTRUCTIONS = `agentPickup lets you buy things online for the user to collect in person.
+1. get_shop: see what the shop sells, its pickup location and how it takes payment.
+2. create_pickup_order: needs the user's email, where the shop sends the pickup QR.
+3. pay_order: pays from the configured wallet in USDC over x402. Confirm the items and total with the user first.
+4. Give the user the pass link and pickup code. They show the QR at the counter to collect.
+get_pickup_pass fetches the pass again later; order_status says whether it's ready or collected.`;
+const money = (cents, currency) => new Intl.NumberFormat("en-US", { style: "currency", currency: currency.toUpperCase() }).format(cents / 100);
+const reply = (summary, data) => ({
+    content: [{ type: "text", text: `${summary}\n\n${JSON.stringify(data, null, 2)}` }],
+});
+const failure = (message) => ({ content: [{ type: "text", text: message }], isError: true });
+export function createPickupMcpServer(opts) {
+    const home = new URL(opts.shopUrl).origin;
+    const doFetch = opts.fetch ?? ((req) => fetch(req));
+    function shopFor(shopUrl) {
+        if (!shopUrl)
+            return home;
+        let url;
+        try {
+            url = new URL(shopUrl);
+        }
+        catch {
+            throw new ToolError(`"${shopUrl}" isn't a URL.`);
+        }
+        if (url.origin === home)
+            return home;
+        if (!opts.allowOtherShops)
+            throw new ToolError(`This server orders from one shop only: ${home}.`);
+        if (url.protocol !== "https:" && url.hostname !== "localhost")
+            throw new ToolError("Shops must be served over https.");
+        return url.origin;
+    }
+    async function call(shop, path, init) {
+        const res = await doFetch(new Request(`${shop}${path}`, init));
+        if (!res.ok)
+            throw new ToolError(await errorOf(res, `The shop answered ${res.status}.`));
+        return res.json();
+    }
+    // Tool errors go back to the model as text it can act on, not as protocol errors.
+    const guarded = (fn) => async (args) => {
+        try {
+            return await fn(args);
+        }
+        catch (err) {
+            if (err instanceof ToolError)
+                return failure(err.message);
+            return failure(`Couldn't reach the shop: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const shopArg = opts.allowOtherShops
+        ? { shop_url: z.string().optional().describe(`An agentPickup shop's URL. Defaults to ${home}.`) }
+        : {};
+    const server = new McpServer({ name: "agentpickup", title: "agentPickup", version: VERSION }, { instructions: INSTRUCTIONS });
+    server.registerTool("get_shop", {
+        title: "See what a shop sells",
+        description: "What the shop sells (item ids and prices), where to collect, and which payments it takes.",
+        inputSchema: { ...shopArg },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, guarded(async (args) => {
+        const shop = shopFor(args.shop_url);
+        const data = await call(shop, "/api/catalog");
+        const merchant = data.merchant;
+        const currency = String(data.currency ?? "usd");
+        const items = data.items.map((i) => ({
+            id: i.id,
+            name: i.name,
+            price: money(i.priceCents, currency),
+            description: i.description,
+        }));
+        const payments = data.payments;
+        return reply(`${merchant.name}${merchant.location?.name ? `, collect at ${merchant.location.name}` : ""}. ` +
+            (payments.x402 ? `Takes USDC over x402 on ${payments.x402.network}.` : "Doesn't take x402 payments."), { shop, merchant: merchant.name, location: merchant.location, currency, items, x402: payments.x402 ?? null });
+    }));
+    server.registerTool("create_pickup_order", {
+        title: "Order for pickup",
+        description: "Create an order to collect in person. Returns the order id and total; pay it with pay_order. " +
+            "The shop emails the pickup QR to `email` once it's paid.",
+        inputSchema: {
+            items: z
+                .array(z.object({ id: z.string().describe("Item id from get_shop"), qty: z.number().int().min(1).max(20) }))
+                .min(1),
+            email: z.string().email().describe("The user's email. The pickup QR goes here."),
+            name: z.string().max(100).optional().describe("Name for the order, shown to staff"),
+            ...shopArg,
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, guarded(async (args) => {
+        const shop = shopFor(args.shop_url);
+        const data = await call(shop, "/api/orders", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ items: args.items, email: args.email, name: args.name, rail: "x402" }),
+        });
+        const order = data.order;
+        const next = data.next;
+        return reply(`Order ${order.id}: ${order.items.map((i) => `${i.qty}× ${i.name}`).join(", ")}, ${money(order.totalCents, order.currency)}. ` +
+            `Confirm with the user, then call pay_order.`, { shop, orderId: order.id, total: money(order.totalCents, order.currency), items: order.items, payUrl: next.url, collectBy: order.collectBy });
+    }));
+    server.registerTool("pay_order", {
+        title: "Pay for an order",
+        description: opts.payer
+            ? `Pay an order in USDC over x402 from wallet ${opts.payer.address}. This spends money: confirm the items and total with the user first. Returns the pickup pass link.`
+            : "No wallet is set up here, so this returns the price and pay link for another x402 client to pay.",
+        inputSchema: { order_id: z.string(), ...shopArg },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, guarded(async (args) => {
+        const shop = shopFor(args.shop_url);
+        const payUrl = `${shop}/api/orders/${encodeURIComponent(args.order_id)}/pay`;
+        if (!opts.payer) {
+            const res = await doFetch(new Request(payUrl, { method: "POST" }));
+            if (res.status !== 402)
+                throw new ToolError(await errorOf(res, "This order isn't waiting for an x402 payment."));
+            // x402 v2 carries the requirements in the PAYMENT-REQUIRED header; older servers put them in the body.
+            const header = res.headers.get("PAYMENT-REQUIRED");
+            const required = (header ? JSON.parse(Buffer.from(header, "base64").toString("utf8")) : await res.json());
+            const accept = required.accepts?.[0];
+            return reply(`Waiting for payment: ${usd(accept?.amount)} USDC on ${accept?.network}. No wallet is configured here; ` +
+                `POST the pay link with any x402 client, or set AGENTPICKUP_WALLET_KEY.`, { orderId: args.order_id, payUrl, amount: usd(accept?.amount), network: accept?.network, asset: accept?.asset, payTo: accept?.payTo });
+        }
+        const paid = await opts.payer.pay({ id: args.order_id, payUrl }, doFetch);
+        if (!paid.ok)
+            throw new ToolError(paid.error);
+        return reply(`Paid ${paid.amount ?? ""} USDC. Pickup pass: ${paid.passUrl}` +
+            (paid.emailedTo ? ` (also emailed to ${paid.emailedTo})` : "") +
+            `. The user shows its QR at the counter.`, { orderId: args.order_id, ...paid, ok: undefined });
+    }));
+    server.registerTool("order_status", {
+        title: "Check an order",
+        description: "Whether an order is waiting for payment, paid, ready to collect, collected or expired.",
+        inputSchema: { order_id: z.string(), ...shopArg },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, guarded(async (args) => {
+        const shop = shopFor(args.shop_url);
+        const { order } = (await call(shop, `/api/orders/${encodeURIComponent(args.order_id)}`));
+        const words = {
+            awaiting_payment: "is waiting for payment",
+            paid: "is paid and being prepared",
+            ready: "is ready to collect",
+            collected: "has been collected",
+            expired: "expired before anyone collected it",
+            cancelled: "was cancelled",
+        };
+        return reply(`Order ${order.id} ${words[order.status] ?? `is ${order.status}`}.`, order);
+    }));
+    server.registerTool("get_pickup_pass", {
+        title: "Get the pickup pass",
+        description: "The pass link, pickup code and QR content for an order this wallet paid, by signing in with the wallet (Sign-In-With-X).",
+        inputSchema: { order_id: z.string(), ...shopArg },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, guarded(async (args) => {
+        if (!opts.payer)
+            throw new ToolError("No wallet is set up here. The pass was emailed to the buyer when the order was paid.");
+        const shop = shopFor(args.shop_url);
+        const res = await opts.payer.signIn(`${shop}/api/orders/${encodeURIComponent(args.order_id)}/pass`, doFetch);
+        if (!res.ok)
+            throw new ToolError(await errorOf(res, `The shop answered ${res.status}.`));
+        const pass = (await res.json());
+        return reply(`Pickup pass: ${pass.passUrl}, pickup code ${pass.pickupCode}.`, pass);
+    }));
+    return server;
+}
+/** A Streamable HTTP endpoint (stateless, JSON responses) for hosting the server, e.g. at /mcp. */
+export function createMcpHandler(opts) {
+    return async (req) => {
+        const server = createPickupMcpServer(opts);
+        const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        await server.connect(transport);
+        return transport.handleRequest(req);
+    };
+}

package/dist/wallet.d.ts

@@ -0,0 +1,33 @@
+export type Fetch = (req: Request) => Response | Promise<Response>;
+export type PayOutcome = {
+    ok: true;
+    passUrl: string;
+    emailedTo?: string;
+    amount?: string;
+    transaction?: string;
+    network?: string;
+    explorer?: string;
+} | {
+    ok: false;
+    error: string;
+};
+export interface Payer {
+    address: string;
+    /** Pay an order's x402 pay link. */
+    pay(order: {
+        id: string;
+        payUrl: string;
+    }, fetch: Fetch): Promise<PayOutcome>;
+    /** Sign in as the paying wallet to read an order's pass again. Returns the shop's response. */
+    signIn(passUrl: string, fetch: Fetch): Promise<Response>;
+}
+export interface WalletPayerOptions {
+    privateKey: `0x${string}`;
+    /** Most the wallet pays for one order, as "$25". Stock x402 clients stop at $1. */
+    maxPerOrder?: string;
+    /** CAIP-2 networks the wallet may pay on. Base Sepolia (test USDC) only unless you say otherwise. */
+    networks?: string[];
+}
+export declare const usd: (units: string | undefined) => string | undefined;
+export declare function errorOf(res: Response, fallback: string): Promise<string>;
+export declare function walletPayer(opts: WalletPayerOptions): Payer;

package/dist/wallet.js

@@ -0,0 +1,66 @@
+// An x402 wallet for the MCP server: pays an order's pay link and signs in with Sign-In-With-X to read
+// the order's pass again later.
+import { x402Client, x402HTTPClient } from "@x402/core/client";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import { createSIWxPayload, encodeSIWxHeader, SIGN_IN_WITH_X } from "@x402/extensions/sign-in-with-x";
+import { privateKeyToAccount } from "viem/accounts";
+const EXPLORERS = {
+    "eip155:8453": "https://basescan.org/tx/",
+    "eip155:84532": "https://sepolia.basescan.org/tx/",
+};
+export const usd = (units) => (units ? (Number(units) / 1e6).toFixed(2) : undefined);
+export async function errorOf(res, fallback) {
+    const body = (await res.clone().json().catch(() => ({})));
+    return body.error ?? fallback;
+}
+export function walletPayer(opts) {
+    const account = privateKeyToAccount(opts.privateKey);
+    const networks = (opts.networks?.length ? opts.networks : ["eip155:84532"]);
+    const http = new x402HTTPClient(x402Client.fromConfig({
+        schemes: networks.map((network) => ({ network, client: new ExactEvmScheme(account) })),
+        spendControls: { maxAmountPerPayment: opts.maxPerOrder ?? "$25" },
+    }));
+    return {
+        address: account.address,
+        async pay(order, fetch) {
+            const challenge = await fetch(new Request(order.payUrl, { method: "POST" }));
+            if (challenge.status !== 402) {
+                return { ok: false, error: await errorOf(challenge, "This order isn't waiting for an x402 payment.") };
+            }
+            const required = http.getPaymentRequiredResponse((n) => challenge.headers.get(n), await challenge.json().catch(() => undefined));
+            let payload;
+            try {
+                payload = await http.createPaymentPayload(required);
+            }
+            catch (err) {
+                return { ok: false, error: `The wallet won't pay this: ${err instanceof Error ? err.message : String(err)}` };
+            }
+            const paid = await fetch(new Request(order.payUrl, { method: "POST", headers: http.encodePaymentSignatureHeader(payload) }));
+            if (!paid.ok)
+                return { ok: false, error: await errorOf(paid, `The payment didn't go through (${paid.status}).`) };
+            const body = (await paid.json());
+            const settled = http.getPaymentSettleResponse((n) => paid.headers.get(n));
+            return {
+                ok: true,
+                passUrl: body.passUrl,
+                emailedTo: body.emailedTo,
+                amount: usd(payload.accepted.amount),
+                transaction: settled.transaction,
+                network: settled.network,
+                explorer: EXPLORERS[settled.network] ? EXPLORERS[settled.network] + settled.transaction : undefined,
+            };
+        },
+        async signIn(passUrl, fetch) {
+            const challenge = await fetch(new Request(passUrl));
+            if (challenge.status !== 402)
+                return challenge;
+            const body = (await challenge.clone().json().catch(() => ({})));
+            const ext = body.extensions?.[SIGN_IN_WITH_X];
+            const chain = ext?.supportedChains.find((c) => c.chainId.startsWith("eip155:"));
+            if (!ext || !chain)
+                return challenge;
+            const signed = await createSIWxPayload({ ...ext.info, chainId: chain.chainId, type: chain.type }, account, passUrl);
+            return fetch(new Request(passUrl, { headers: { "SIGN-IN-WITH-X": encodeSIWxHeader(signed) } }));
+        },
+    };
+}

package/package.json

@@ -1,6 +1,62 @@
-{
-  "name": "@agentpickup/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@agentpickup/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for agentPickup: let an AI agent order from a shop, pay over x402, and hand its user the QR to collect in person.",
+  "mcpName": "io.github.dav3trad3r/agentpickup",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "agentpickup-mcp": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "x402",
+    "agentic-commerce",
+    "agent-payments",
+    "click-and-collect",
+    "pickup"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dav3trad3r/agentpickup.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/dav3trad3r/agentpickup#readme",
+  "bugs": {
+    "url": "https://github.com/dav3trad3r/agentpickup/issues"
+  },
+  "author": "Dave Hallett",
+  "license": "FSL-1.1-ALv2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@x402/core": "2.29.0",
+    "@x402/evm": "2.29.0",
+    "@x402/extensions": "2.29.0",
+    "viem": "^2.57.14",
+    "zod": "^4.6.7"
+  }
+}