@dishtaweera/wise-mcp 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deepana Ishtaweera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,156 @@
-# Temporary Holding Version
+# wise-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 the [Wise](https://wise.com) (formerly TransferWise) API. It lets Claude, ChatGPT or any MCP agent check your balances, look up exchange rates, price transfers, manage recipients, and create, fund or track transfers. It authenticates with your Wise personal API token.
+
+Built against **Wise Platform API version `2026Q4`** (`https://api.wise.com/2026Q4`). It runs locally over **stdio** for Claude Desktop and Claude Code, and over **Streamable HTTP** for ChatGPT, claude.ai and other remote clients.
+
+## Tools
+
+| Access level | Tool | Wise endpoint |
+|---|---|---|
+| `read` | `wise_list_profiles` | `GET /profiles` |
+| | `wise_get_balances` | `GET /profiles/{id}/balances` |
+| | `wise_get_exchange_rate` | `GET /rates` (current, historic, history) |
+| | `wise_list_currencies` | `GET /currencies` |
+| | `wise_create_quote` / `wise_get_quote` | `POST/GET /profiles/{id}/quotes` (moves no money) |
+| | `wise_list_recipients` / `wise_get_recipient` | `GET /accounts` |
+| | `wise_get_recipient_requirements` | `GET /quotes/{id}/account-requirements` |
+| | `wise_list_transfers` / `wise_get_transfer` | `GET /transfers` |
+| | `wise_get_delivery_estimate` | `GET /delivery-estimates/{id}` |
+| | `wise_list_activities` | `GET /profiles/{id}/activities` |
+| | `wise_get_balance_statement` | `GET /profiles/{id}/balance-statements/{balanceId}/statement.json` |
+| `write` | `wise_create_recipient` | `POST /accounts` |
+| | `wise_create_transfer` | `POST /transfers` (a draft; no money moves yet) |
+| | `wise_cancel_transfer` | `PUT /transfers/{id}/cancel` |
+| `payments` | `wise_fund_transfer` | `POST /profiles/{id}/transfers/{id}/payments` (**sends money**) |
+
+`WISE_ACCESS` picks the level, and each level includes the ones above it.
+
+**Recommended: keep the default `read`.** It covers recording and bookkeeping (balances, activity feed, transfer history, statements and rates) and an agent can't create or send anything at that level. `write` and `payments` are there if you ever need them, but they aren't recommended for agents. For recording, `wise_list_activities` and `wise_list_transfers` work with any personal token. `wise_get_balance_statement` gives line-by-line transactions, but only for accounts in the countries listed below. Tools above your level aren't registered at all, so the agent never sees them. `wise_fund_transfer` and `wise_cancel_transfer` are marked `destructiveHint`, so Claude and ChatGPT ask you before calling them.
+
+A typical send flow:
+
+```
+list_profiles → create_quote → list_recipients (or get_recipient_requirements → create_recipient)
+→ create_transfer → [you confirm] → fund_transfer → get_transfer / get_delivery_estimate
+```
+
+## What a personal token can and can't do
+
+Wise documents these limits ([Personal API tokens](https://docs.wise.com/guides/developer/auth-and-security/personal-api-token)):
+
+- Personal tokens are issued for **business accounts** (Settings → Connect and manage apps → API tokens).
+- **Funding transfers and balance statements** only work for accounts based in the **US, Canada, Australia, New Zealand, Singapore and Malaysia**. Anywhere else, create the transfer with `wise_create_transfer` and approve it in the Wise app.
+- **UK/EEA profiles** need Strong Customer Authentication (SCA) on protected calls. This server handles it automatically if you give it a key (see below).
+- Some endpoints in Wise's reference are marked "user token only" but work with personal tokens. If one comes back with 403, Wise doesn't allow it for your token type.
+
+## Setup
+
+Published on npm as [`@dishtaweera/wise-mcp`](https://www.npmjs.com/package/@dishtaweera/wise-mcp). Your MCP client runs it with `npx`, so there is nothing to install or clone:
+
+```bash
+npx -y @dishtaweera/wise-mcp
+```
+
+Requires Node 20+. Pass the variables below through your MCP client config. Try it against the **sandbox** first: create an account at [wise-sandbox.com](https://wise-sandbox.com), make an API token there, and leave `WISE_ENV=sandbox` (the default). Set `WISE_ENV=production` when you're ready.
+
+| Variable | |
+|---|---|
+| `WISE_API_TOKEN` | **Required.** Your personal API token |
+| `WISE_ENV` | `sandbox` (default) or `production` |
+| `WISE_ACCESS` | `read` (default, recommended), `write` or `payments` (not recommended) |
+| `WISE_PROFILE_ID` | Optional default profile, so tools don't need `profileId` |
+| `WISE_PRIVATE_KEY_PATH` / `WISE_PRIVATE_KEY` | Optional RSA private key for SCA (a file path, or the inline PEM) |
+| `MCP_AUTH_TOKEN` | HTTP mode only, **required** there: a shared secret of at least 32 characters |
+| `PORT` | HTTP mode port (default 3000) |
+
+### Claude Desktop
+
+Add this to `~/Library/Application Support/Claude/claude_desktop_config.json` (on Windows, `%APPDATA%\Claude\claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "wise": {
+      "command": "npx",
+      "args": ["-y", "@dishtaweera/wise-mcp"],
+      "env": {
+        "WISE_API_TOKEN": "your-token",
+        "WISE_ENV": "sandbox",
+        "WISE_ACCESS": "read"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add wise -e WISE_API_TOKEN=your-token -e WISE_ENV=sandbox -- npx -y @dishtaweera/wise-mcp
+```
+
+### ChatGPT desktop app (local)
+
+The ChatGPT desktop app can run local stdio servers through its Codex settings. Add this to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.wise]
+command = "npx"
+args = ["-y", "@dishtaweera/wise-mcp"]
+
+[mcp_servers.wise.env]
+WISE_API_TOKEN = "your-token"
+WISE_ENV = "sandbox"
+WISE_ACCESS = "read"
+```
+
+### ChatGPT web (and claude.ai custom connectors)
+
+These clients connect to a **remote HTTPS** URL, so run the server in HTTP mode:
+
+```bash
+export MCP_AUTH_TOKEN=$(openssl rand -hex 32)
+WISE_API_TOKEN=your-token npx -y @dishtaweera/wise-mcp --http     # http://localhost:3000/mcp
+```
+
+Expose it over HTTPS. For a quick test, use a tunnel such as `cloudflared tunnel --url http://localhost:3000`. For anything lasting, deploy it to any Node host and set the environment variables there.
+
+ChatGPT connectors support only OAuth or no auth; they can't send a custom header. So the server also accepts the secret as the last part of the URL path:
+
+- **ChatGPT**: Settings → Apps & Connectors → Advanced → turn on **Developer mode**, then create a connector with URL `https://your-host/mcp/<MCP_AUTH_TOKEN>` and authentication set to **No authentication**.
+- **claude.ai**: Settings → Connectors → Add custom connector, using the same URL.
+- **Clients that can send headers**: use `https://your-host/mcp` with `Authorization: Bearer <MCP_AUTH_TOKEN>`.
+
+Treat that URL like a password: anyone who has it can use your Wise account at the access level you set. Use HTTPS only, and change `MCP_AUTH_TOKEN` if the URL leaks.
+
+## SCA (UK/EEA accounts)
+
+When Wise needs extra authentication, it answers a request with `403` and a one-time token in the `x-2fa-approval` header. The server signs that token with your private key (SHA256withRSA, base64) and resends the request with `x-2fa-approval` and `X-Signature` headers. To set it up:
+
+```bash
+openssl genrsa -out wise-private.pem 2048
+openssl rsa -pubout -in wise-private.pem -out wise-public.pem
+```
+
+Upload `wise-public.pem` in Wise under Settings → API tokens → Manage public keys. Then set `WISE_PRIVATE_KEY_PATH=/path/to/wise-private.pem`. In the sandbox, SCA is off until you enable it on that same page.
+
+## Development
+
+```bash
+git clone https://github.com/deepanaishtaweera/wise-mcp && cd wise-mcp
+npm install
+npm test          # builds, then runs node:test against a mocked Wise API
+```
+
+The code is in three files: `src/wise.ts` (HTTP client and SCA signing), `src/tools.ts` (tool definitions) and `src/index.ts` (config and the stdio/HTTP transports). Responses are passed through as Wise's raw JSON text. Wise IDs are int64, so this avoids any chance of rounding them.
+
+## References
+
+- [Wise API reference (2026Q4)](https://docs.wise.com/api-reference) and its [OpenAPI spec](https://docs.wise.com/_bundle/api-reference/@latest/index.yaml)
+- [Versioning](https://docs.wise.com/guides/developer/global-versioning)
+- [Personal API tokens](https://docs.wise.com/guides/developer/auth-and-security/personal-api-token)
+- [SCA over API](https://docs.wise.com/guides/developer/auth-and-security/sca-over-api) and [One Time Token](https://docs.wise.com/guides/developer/auth-and-security/one-time-token)
+- [Fund a transfer](https://docs.wise.com/api-reference/transfer/transferfund)
+- [Sandbox v2 migration](https://docs.wise.com/guides/developer/environments/sandbox-v2-migration)
+- [ChatGPT developer mode](https://developers.openai.com/api/docs/guides/developer-mode)

package/dist/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { timingSafeEqual } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { ACCESS_LEVELS, registerTools } from "./tools.js";
+import { createWiseClient } from "./wise.js";
+const env = process.env;
+const fail = (msg) => {
+    console.error(`wise-mcp: ${msg}`);
+    process.exit(1);
+};
+const token = env.WISE_API_TOKEN ?? fail("WISE_API_TOKEN is required (Wise > Settings > API tokens).");
+const wiseEnv = (env.WISE_ENV ?? "sandbox");
+if (wiseEnv !== "sandbox" && wiseEnv !== "production")
+    fail("WISE_ENV must be sandbox or production.");
+const access = (env.WISE_ACCESS ?? "read");
+if (!ACCESS_LEVELS.includes(access))
+    fail(`WISE_ACCESS must be one of ${ACCESS_LEVELS.join(", ")}.`);
+const defaultProfileId = env.WISE_PROFILE_ID ? Number(env.WISE_PROFILE_ID) : undefined;
+const privateKey = env.WISE_PRIVATE_KEY ?? (env.WISE_PRIVATE_KEY_PATH && readFileSync(env.WISE_PRIVATE_KEY_PATH, "utf8"));
+const wise = createWiseClient({ token, env: wiseEnv, privateKey: privateKey || undefined });
+function buildServer() {
+    const server = new McpServer({ name: "wise-mcp", version: "1.0.0" }, {
+        instructions: `Wise (${wiseEnv}) banking tools, access level "${access}". ` +
+            "Typical send flow: wise_list_profiles -> wise_create_quote -> wise_list_recipients or " +
+            "wise_get_recipient_requirements + wise_create_recipient -> wise_create_transfer -> wise_fund_transfer. " +
+            "Always show the user the quote (amounts, fee, rate, recipient) and get explicit confirmation before funding a transfer.",
+    });
+    registerTools(server, wise, { access, defaultProfileId });
+    return server;
+}
+if (process.argv.includes("--http") || env.MCP_TRANSPORT === "http") {
+    // Exposes a bank account to the network, so refuse to run without a shared secret.
+    const secret = env.MCP_AUTH_TOKEN ?? "";
+    if (secret.length < 32)
+        fail("HTTP mode needs MCP_AUTH_TOKEN of at least 32 chars (e.g. `openssl rand -hex 32`).");
+    const port = Number(env.PORT ?? 3000);
+    const same = (a) => a.length === secret.length && timingSafeEqual(Buffer.from(a), Buffer.from(secret));
+    createServer(async (req, res) => {
+        const path = new URL(req.url ?? "/", "http://x").pathname;
+        const bearer = req.headers.authorization?.replace(/^Bearer /i, "") ?? "";
+        // ChatGPT connectors can't send custom headers, so the secret may also be the last path segment: /mcp/<secret>
+        const authed = (path === "/mcp" && same(bearer)) || (path.startsWith("/mcp/") && same(path.slice(5)));
+        if (!authed) {
+            res.writeHead(path === "/mcp" || path.startsWith("/mcp/") ? 401 : 404).end();
+            return;
+        }
+        // Stateless: a fresh server per request keeps horizontal scaling and restarts trivial.
+        const server = buildServer();
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on("close", () => {
+            transport.close();
+            server.close();
+        });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res);
+        }
+        catch (e) {
+            console.error(e);
+            if (!res.headersSent)
+                res.writeHead(500).end();
+        }
+    }).listen(port, () => console.error(`wise-mcp (${wiseEnv}, ${access}) listening on http://localhost:${port}/mcp`));
+}
+else {
+    await buildServer().connect(new StdioServerTransport());
+    console.error(`wise-mcp (${wiseEnv}, ${access}) running on stdio`);
+}

package/dist/tools.js

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+export const ACCESS_LEVELS = ["read", "write", "payments"];
+const id = (what) => z.number().int().positive().describe(what);
+const currency = (what) => z.string().length(3).toUpperCase().describe(`${what} (ISO 4217, e.g. EUR)`);
+const profileId = id("Wise profile ID. Optional when WISE_PROFILE_ID is set; get it from wise_list_profiles.").optional();
+export function registerTools(server, wise, opts) {
+    const pid = (p) => {
+        const v = p ?? opts.defaultProfileId;
+        if (!v)
+            throw new Error("profileId is required: call wise_list_profiles first, or set WISE_PROFILE_ID.");
+        return v;
+    };
+    const tool = (level, name, config, run) => {
+        if (ACCESS_LEVELS.indexOf(level) > ACCESS_LEVELS.indexOf(opts.access))
+            return;
+        server.registerTool(name, {
+            title: config.title,
+            description: config.description,
+            inputSchema: config.inputSchema,
+            annotations: {
+                title: config.title,
+                readOnlyHint: config.readOnly ?? false,
+                destructiveHint: config.destructive ?? false,
+                openWorldHint: true,
+            },
+        }, 
+        // @ts-expect-error SDK's generic callback type doesn't narrow from our generic shape
+        async (args) => {
+            try {
+                return { content: [{ type: "text", text: (await run(args)) || "OK" }] };
+            }
+            catch (e) {
+                return { isError: true, content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }] };
+            }
+        });
+    };
+    // ---------- read ----------
+    tool("read", "wise_list_profiles", {
+        title: "List profiles",
+        description: "List the Wise profiles (personal and business) this token can access. Most other tools need a profile ID from here.",
+        inputSchema: {},
+        readOnly: true,
+    }, () => wise.request("GET", "/profiles"));
+    tool("read", "wise_get_balances", {
+        title: "Get balances",
+        description: "Get multi-currency balances for a profile: amount, reserved amount and balance ID per currency.",
+        inputSchema: { profileId, types: z.string().default("STANDARD").describe("Comma-separated: STANDARD, SAVINGS") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/profiles/${pid(a.profileId)}/balances`, { query: { types: a.types } }));
+    tool("read", "wise_get_exchange_rate", {
+        title: "Get exchange rate",
+        description: "Get the current mid-market rate for a currency pair, a historic rate at `time`, or a history between `from` and `to` grouped by `group`.",
+        inputSchema: {
+            source: currency("Source currency"),
+            target: currency("Target currency"),
+            time: z.string().optional().describe("ISO 8601 timestamp for a historic rate"),
+            from: z.string().optional().describe("History start (ISO 8601 date or timestamp)"),
+            to: z.string().optional().describe("History end (ISO 8601 date or timestamp)"),
+            group: z.enum(["day", "hour", "minute"]).optional(),
+        },
+        readOnly: true,
+    }, (a) => wise.request("GET", "/rates", { query: a }));
+    tool("read", "wise_list_currencies", {
+        title: "List currencies",
+        description: "List all currencies Wise can send to.",
+        inputSchema: {},
+        readOnly: true,
+    }, () => wise.request("GET", "/currencies"));
+    tool("read", "wise_create_quote", {
+        title: "Create quote",
+        description: "Price a transfer: returns the rate, fees, delivery estimate and a quote ID (valid ~30 min) needed to create a transfer. " +
+            "Moves no money, but needs a full-access token (read-only tokens get error.quote.mustBeAuthenticated); " +
+            "use wise_get_exchange_rate for rates alone. Give exactly one of sourceAmount or targetAmount.",
+        inputSchema: {
+            profileId,
+            sourceCurrency: currency("Currency you send"),
+            targetCurrency: currency("Currency the recipient gets"),
+            sourceAmount: z.number().positive().optional(),
+            targetAmount: z.number().positive().optional(),
+            targetAccount: id("Recipient ID, if already known (gives a more accurate fee)").optional(),
+            preferredPayIn: z.string().default("BALANCE").describe("BALANCE to pay from your Wise balance, or BANK_TRANSFER"),
+        },
+    }, (a) => {
+        if ((a.sourceAmount === undefined) === (a.targetAmount === undefined)) {
+            throw new Error("Give exactly one of sourceAmount or targetAmount.");
+        }
+        const { profileId: p, ...body } = a;
+        return wise.request("POST", `/profiles/${pid(p)}/quotes`, { body });
+    });
+    tool("read", "wise_get_quote", {
+        title: "Get quote",
+        description: "Fetch an existing quote by ID.",
+        inputSchema: { profileId, quoteId: z.string().describe("Quote ID (UUID)") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/profiles/${pid(a.profileId)}/quotes/${encodeURIComponent(a.quoteId)}`));
+    tool("read", "wise_list_recipients", {
+        title: "List recipients",
+        description: "List saved recipient accounts. Paginate with seekPosition from the previous response's seekPositionForNext.",
+        inputSchema: {
+            profileId,
+            currency: currency("Filter by target currency").optional(),
+            size: z.number().int().min(1).max(20).optional(),
+            seekPosition: z.number().int().optional(),
+        },
+        readOnly: true,
+    }, (a) => wise.request("GET", "/accounts", { query: { ...a, profileId: pid(a.profileId) } }));
+    tool("read", "wise_get_recipient", {
+        title: "Get recipient",
+        description: "Fetch one recipient account by ID.",
+        inputSchema: { recipientId: id("Recipient account ID") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/accounts/${a.recipientId}`));
+    tool("read", "wise_get_recipient_requirements", {
+        title: "Get recipient requirements",
+        description: "For a quote, list which recipient account types exist for the route (e.g. iban, sort_code, aba) and the exact fields each needs. " +
+            "Call this before wise_create_recipient.",
+        inputSchema: { quoteId: z.string().describe("Quote ID from wise_create_quote") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/quotes/${encodeURIComponent(a.quoteId)}/account-requirements`));
+    tool("read", "wise_list_transfers", {
+        title: "List transfers",
+        description: "List transfers for a profile, OLDEST first, optionally filtered by status, currency and creation date. " +
+            "For recent transfers set createdDateStart rather than relying on order.",
+        inputSchema: {
+            profileId,
+            status: z.string().optional().describe("Comma-separated, e.g. incoming_payment_waiting,processing,outgoing_payment_sent,cancelled"),
+            sourceCurrency: currency("Source currency").optional(),
+            targetCurrency: currency("Target currency").optional(),
+            createdDateStart: z.string().optional().describe("ISO 8601 date, inclusive"),
+            createdDateEnd: z.string().optional().describe("ISO 8601 date, inclusive"),
+            limit: z.number().int().min(1).max(100).default(20),
+            offset: z.number().int().min(0).default(0),
+        },
+        readOnly: true,
+    }, ({ profileId: p, ...q }) => wise.request("GET", "/transfers", { query: { ...q, profile: pid(p) } }));
+    tool("read", "wise_get_transfer", {
+        title: "Get transfer",
+        description: "Get a transfer's details and current status.",
+        inputSchema: { transferId: id("Transfer ID") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/transfers/${a.transferId}`));
+    tool("read", "wise_get_delivery_estimate", {
+        title: "Get delivery estimate",
+        description: "Get when a transfer is expected to arrive.",
+        inputSchema: { transferId: id("Transfer ID"), timezone: z.string().optional().describe("e.g. Europe/London") },
+        readOnly: true,
+    }, (a) => wise.request("GET", `/delivery-estimates/${a.transferId}`, { query: { timezone: a.timezone } }));
+    tool("read", "wise_list_activities", {
+        title: "List activities",
+        description: "List recent account activity (card spend, transfers, conversions, top-ups). Paginate with nextCursor from the previous response's cursor.",
+        inputSchema: {
+            profileId,
+            status: z.enum(["REQUIRES_ATTENTION", "IN_PROGRESS", "UPCOMING", "COMPLETED", "CANCELLED"]).optional(),
+            since: z.string().optional().describe("ISO 8601 timestamp"),
+            until: z.string().optional().describe("ISO 8601 timestamp"),
+            size: z.number().int().min(1).max(100).optional(),
+            nextCursor: z.string().optional(),
+        },
+        readOnly: true,
+    }, ({ profileId: p, ...q }) => wise.request("GET", `/profiles/${pid(p)}/activities`, { query: q }));
+    tool("read", "wise_get_balance_statement", {
+        title: "Get balance statement",
+        description: "Get the transactions on one balance between two times. Needs SCA (WISE_PRIVATE_KEY_PATH) for UK/EEA profiles; " +
+            "personal tokens only support this for US, CA, AU, NZ, SG and MY accounts.",
+        inputSchema: {
+            profileId,
+            balanceId: id("Balance ID from wise_get_balances"),
+            currency: currency("Balance currency"),
+            intervalStart: z.string().describe("UTC ISO 8601, e.g. 2026-10-01T00:00:00.000Z"),
+            intervalEnd: z.string().describe("UTC ISO 8601; max 469 days after start"),
+            type: z.enum(["COMPACT", "FLAT"]).default("COMPACT"),
+        },
+        readOnly: true,
+    }, ({ profileId: p, balanceId, ...q }) => wise.request("GET", `/profiles/${pid(p)}/balance-statements/${balanceId}/statement.json`, { query: q }));
+    // ---------- write: creates records, moves no money ----------
+    tool("write", "wise_create_recipient", {
+        title: "Create recipient",
+        description: "Save a recipient bank account. Get `type` and the required `details` fields from wise_get_recipient_requirements first " +
+            "(e.g. GBP sort_code: {legalType, sortCode, accountNumber}; EUR iban: {legalType, iban}).",
+        inputSchema: {
+            profileId,
+            currency: currency("Recipient account currency"),
+            type: z.string().describe("Account type from requirements, e.g. iban, sort_code, aba"),
+            accountHolderName: z.string().min(1),
+            ownedByCustomer: z.boolean().optional().describe("True if the account belongs to the profile owner"),
+            details: z.record(z.string(), z.unknown()).describe("Route-specific fields from the requirements"),
+        },
+    }, ({ profileId: p, ...rest }) => wise.request("POST", "/accounts", { body: { ...rest, profile: pid(p) } }));
+    tool("write", "wise_create_transfer", {
+        title: "Create transfer (draft)",
+        description: "Create a transfer from a quote to a recipient. This is a draft: no money leaves until it is funded " +
+            "(wise_fund_transfer, or in the Wise app). One transfer per quote.",
+        inputSchema: {
+            quoteUuid: z.string().describe("Quote ID from wise_create_quote"),
+            targetAccount: id("Recipient ID"),
+            reference: z.string().max(100).optional().describe("Shown on the recipient's statement; max length varies by route"),
+            details: z.record(z.string(), z.unknown()).optional().describe("Extra route-specific fields, e.g. transferPurpose, sourceOfFunds"),
+            customerTransactionId: z.string().uuid().optional().describe("Idempotency key; generated if omitted"),
+        },
+    }, (a) => wise.request("POST", "/transfers", {
+        body: {
+            targetAccount: a.targetAccount,
+            quoteUuid: a.quoteUuid,
+            customerTransactionId: a.customerTransactionId ?? randomUUID(),
+            details: { ...a.details, ...(a.reference !== undefined && { reference: a.reference }) },
+        },
+    }));
+    tool("write", "wise_cancel_transfer", {
+        title: "Cancel transfer",
+        description: "Cancel a transfer. Only works while it is still incoming_payment_waiting.",
+        inputSchema: { transferId: id("Transfer ID") },
+        destructive: true,
+    }, (a) => wise.request("PUT", `/transfers/${a.transferId}/cancel`));
+    // ---------- payments: moves real money ----------
+    tool("payments", "wise_fund_transfer", {
+        title: "Fund transfer (sends money)",
+        description: "Pay a created transfer from your Wise balance. THIS SENDS REAL MONEY and cannot be undone once processed. " +
+            "Only call after the user has explicitly confirmed the amount and recipient. " +
+            "Personal tokens support this only for US, CA, AU, NZ, SG and MY accounts; UK/EEA needs SCA (WISE_PRIVATE_KEY_PATH).",
+        inputSchema: {
+            profileId,
+            transferId: id("Transfer ID from wise_create_transfer"),
+            balanceId: id("Balance to debit; defaults to the balance in the transfer's source currency").optional(),
+        },
+        destructive: true,
+    }, (a) => wise.request("POST", `/profiles/${pid(a.profileId)}/transfers/${a.transferId}/payments`, {
+        body: { type: "BALANCE", ...(a.balanceId && { balanceId: a.balanceId }) },
+    }));
+}

package/dist/wise.js

@@ -0,0 +1,43 @@
+import { createSign, randomUUID } from "node:crypto";
+export const API_VERSION = "2026Q4";
+const HOSTS = {
+    sandbox: "https://api.wise-sandbox.com",
+    production: "https://api.wise.com",
+};
+export function createWiseClient(opts) {
+    const base = `${HOSTS[opts.env]}/${API_VERSION}`;
+    return {
+        async request(method, path, { query, body } = {}) {
+            const url = new URL(base + path);
+            for (const [k, v] of Object.entries(query ?? {}))
+                if (v !== undefined)
+                    url.searchParams.set(k, String(v));
+            const headers = {
+                Authorization: `Bearer ${opts.token}`,
+                Accept: "application/json",
+                "X-External-Correlation-Id": randomUUID(),
+            };
+            if (body !== undefined)
+                headers["Content-Type"] = "application/json";
+            const send = (extra = {}) => fetch(url, { method, headers: { ...headers, ...extra }, body: body === undefined ? undefined : JSON.stringify(body) });
+            let res = await send();
+            // SCA: Wise answers 403 with a one-time token that must be signed (SHA256withRSA) and replayed.
+            const ott = res.headers.get("x-2fa-approval");
+            if (res.status === 403 && ott && res.headers.get("x-2fa-approval-result") === "REJECTED") {
+                if (!opts.privateKey) {
+                    throw new Error("Wise requires Strong Customer Authentication for this call. Set WISE_PRIVATE_KEY_PATH to the RSA private key " +
+                        "whose public key is uploaded in Wise (Settings > API tokens > Manage public keys).");
+                }
+                const signature = createSign("SHA256").update(ott).sign(opts.privateKey, "base64");
+                res = await send({ "x-2fa-approval": ott, "X-Signature": signature });
+            }
+            // Returned verbatim: Wise IDs are int64, so avoid a JSON round-trip that could round them.
+            const text = await res.text();
+            if (!res.ok) {
+                const trace = res.headers.get("x-trace-id");
+                throw new Error(`Wise API ${method} ${path} failed with HTTP ${res.status}${trace ? ` (x-trace-id ${trace})` : ""}: ${text.slice(0, 4000)}`);
+            }
+            return text;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@dishtaweera/wise-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "MCP server for the Wise (TransferWise) API: balances, quotes, recipients and transfers for Claude, ChatGPT and other agents",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:http": "node dist/index.js --http",
+    "test": "npm run build && node --test test/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "typescript": "^7.0.2"
+  },
+  "bin": {
+    "wise-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "author": "Deepana Ishtaweera",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepanaishtaweera/wise-mcp.git"
+  },
+  "homepage": "https://github.com/deepanaishtaweera/wise-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/deepanaishtaweera/wise-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "wise",
+    "transferwise",
+    "banking",
+    "exchange-rates",
+    "claude",
+    "chatgpt"
+  ]
+}