earnrate 0.2.14 → 0.2.16

package/dist/mcp/tools/wallet.js

@@ -63,12 +63,199 @@ function changes(catalog, args) {
         out.push(`welcome bonus tracked from ${args.bonus.opened}, ${money(args.bonus.spent ?? 0)} spent so far`);
     return out;
 }
-// The tools that read or change a saved wallet.
-export function registerWalletTools(server, deps, ctx, inputs) {
+// The saved wallet with its summary and to-do list, as list_wallet shows it.
+export async function walletListing(deps, ctx) {
+    const read = await ctx.readableWallet();
+    if (typeof read === 'string')
+        return read;
+    const started = deps.savedWallets === 'account' ? await deps.store.started() : null;
+    const base = walletSummary(deps.catalog, read.wallet, deps.today());
+    const summary = {
+        ...base,
+        started,
+        checklist: checklist(deps.catalog, read.wallet, deps.today(), base, cardText(deps.catalog).shortName),
+    };
+    return { ...read, summary };
+}
+export function walletHandlers(deps, ctx, inputs) {
     const { catalog, store } = deps;
+    const listWallet = {
+        input: z.object({}),
+        run: async () => {
+            const found = await walletListing(deps, ctx);
+            if (typeof found === 'string')
+                return fail(found);
+            const { start, summary } = found;
+            const when = summary.started === null
+                ? `This is ${ctx.walletName}.\n`
+                : `This is ${ctx.walletName}. ${startedText(summary.started, Date.now())}\n`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${when}${start === null ? '' : `${start}\n`}${formatChecklist(summary.checklist)}${formatWalletSummary(summary)}`,
+                    },
+                ],
+                structuredContent: summary,
+            };
+        },
+    };
+    const RecordInput = z.object({
+        cardId: z
+            .string()
+            .min(1)
+            .describe('The card used, as a cardId from list_wallet or best_card_for_purchase.'),
+        merchant: Merchant,
+        amount: z.number().positive().describe('Amount spent in US dollars.'),
+        channel: ChannelInput,
+        date: DateInput,
+        category: inputs.RecordCategoryInput,
+    });
+    const recordPurchase = {
+        input: RecordInput,
+        run: async ({ cardId, merchant, amount, channel, date, category }) => {
+            const w = await ctx.wallet();
+            if (typeof w === 'string')
+                return fail(w);
+            if (!w.cards.some((c) => c.id === cardId))
+                return fail(`"${cardId}" isn't in the wallet. Cards: ${w.cards.map((c) => c.id).join(', ')}.`);
+            const purchase = {
+                cardId,
+                merchant,
+                amount,
+                channel: channel ?? null,
+                date: date ?? deps.today(),
+            };
+            const resolved = await ctx.resolve(merchant, purchase.channel, category ?? null);
+            if (resolved.merchant.source === 'none')
+                return fail(`earnrate doesn't recognize "${merchant}", so it can't tell which caps this purchase counts toward. Nothing was recorded. Call record_purchase again with category if you can tell what kind of business it is (a restaurant, a grocery store, a gas station), or ask the user. If nobody knows, category "other" records it toward a welcome bonus without touching any cap.`);
+            const result = await store.record(purchase, resolved.merchant);
+            if (!result.ok)
+                return fail(`Couldn't record it: ${result.error}`);
+            const { cap: booking, bonus, milestones, credit } = result;
+            const capLabel = booking
+                ? (walletSummary(catalog, w, purchase.date)
+                    .cards.find((c) => c.cardId === cardId)
+                    ?.caps.find((c) => c.key === booking.capKey)?.label ?? null)
+                : null;
+            const output = booking || bonus || milestones.length > 0 || credit
+                ? {
+                    recorded: true,
+                    booking,
+                    bonus,
+                    milestones,
+                    credit,
+                    message: `${formatBooking(amount, cardText(catalog).shortName(cardId), booking, bonus, milestones, credit, capLabel)} Saved in ${ctx.walletName}.`,
+                }
+                : {
+                    recorded: false,
+                    booking: null,
+                    bonus: null,
+                    milestones: [],
+                    credit: null,
+                    message: `Nothing to track: ${cardText(catalog).shortName(cardId)} has no spending cap, open welcome bonus, spend bonus or enrolled statement credit for this purchase, so the wallet wasn't changed.`,
+                };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: [output.message, ...resolved.notices].join('\n'),
+                    },
+                ],
+                structuredContent: output,
+            };
+        },
+    };
+    const addCard = {
+        input: CardChange,
+        run: async (args) => {
+            const result = await store.addCard(cardInput(args), deps.today());
+            const started = !result.ok || !result.created
+                ? ''
+                : deps.savedWallets === 'account'
+                    ? ', the first card in your saved wallet'
+                    : `, starting a new wallet at ${store.where}`;
+            return ctx.changed(result, `Added ${ctx.cardName(args.cardId)} (${args.cardId})${started}.`);
+        },
+    };
+    const updateCard = {
+        input: CardChange,
+        run: async (args) => {
+            const what = changes(catalog, args);
+            const card = catalog.cards.find((c) => c.id === args.cardId);
+            const unused = args.anniversary !== undefined && card && !needsAnniversary(card)
+                ? " None of its caps reset on the account anniversary, so earnrate doesn't use it."
+                : '';
+            return ctx.changed(await store.updateCard(cardInput(args), deps.today()), `Updated ${ctx.cardName(args.cardId)} (${args.cardId})${what.length > 0 ? `: ${what.join('; ')}` : ''}.${unused}`);
+        },
+    };
+    const RemoveInput = z.object({ cardId: CardId });
+    const removeCard = {
+        input: RemoveInput,
+        run: async ({ cardId }) => ctx.changed(await store.removeCard(cardId), `Removed ${ctx.cardName(cardId)} (${cardId}).`, { notes: false }),
+    };
+    const MembershipsInput = z.object({ memberships: inputs.AllMemberships });
+    const setMemberships = {
+        input: MembershipsInput,
+        run: async ({ memberships }) => {
+            const result = await store.setMemberships(memberships);
+            const used = new Set((result.ok ? result.wallet.cards : []).flatMap((held) => {
+                const card = catalog.cards.find((c) => c.id === held.id);
+                return card ? membershipsFor(card) : [];
+            }));
+            const unused = memberships.filter((m) => !used.has(m));
+            return ctx.changed(result, `${memberships.length > 0
+                ? `Memberships set to ${memberships.map((m) => `${membershipName(catalog, m)} (${m})`).join(', ')}.`
+                : 'Memberships cleared.'}${unused.length > 0 ? ` ${listed(unused.map((m) => membershipName(catalog, m)))} ${unused.length === 1 ? "doesn't" : "don't"} change any saved card's rates yet; kept for cards that use ${unused.length === 1 ? 'it' : 'them'}.` : ''}`, { notes: false });
+        },
+    };
+    const PointValuesInput = z.object({
+        values: z
+            .record(z.string(), z.number().nullable())
+            .optional()
+            .describe('Cents per point by currency id, e.g. {"UR": 1.5, "MR": 1.6}. null goes back to the default.'),
+        profile: z
+            .enum(['flat', 'points-heavy'])
+            .optional()
+            .describe(`A preset: flat (${profileText('flat')}) or points-heavy (${profileText('points-heavy')}). Values given too win over it.`),
+    });
+    const setPointValues = {
+        input: PointValuesInput,
+        run: async ({ values, profile }) => {
+            const given = currencyChanges(catalog, values ?? {});
+            if (!given.ok)
+                return fail(given.error);
+            const changes = {
+                ...(profile ? VALUATION_PROFILES[profile] : {}),
+                ...given.changes,
+            };
+            if (Object.keys(changes).length === 0)
+                return fail('Give values (cents per point by currency) or a profile.');
+            const result = await store.setValuations(changes);
+            const set = Object.entries(changes).map(([id, cents]) => cents === null
+                ? `${currencyLabel(catalog, id)} back to the default`
+                : `${currencyLabel(catalog, id)} at ${String(cents)}¢`);
+            return ctx.changed(result, `Point values: ${set.join(', ')}.`, {
+                notes: false,
+            });
+        },
+    };
+    return {
+        list_wallet: listWallet,
+        record_purchase: recordPurchase,
+        add_card: addCard,
+        update_card: updateCard,
+        remove_card: removeCard,
+        set_memberships: setMemberships,
+        set_point_values: setPointValues,
+    };
+}
+export function registerWalletTools(server, deps, ctx, inputs) {
+    const { catalog } = deps;
+    const tools = walletHandlers(deps, ctx, inputs);
     server.registerTool('list_wallet', {
         title: 'List wallet',
-        description: `Starts with a to-do list for the user's cards right now (bonuses to activate and their deadlines, categories to pick or confirm, caps nearly used up, welcome bonuses to finish and the weekly pace, yearly spend bonuses at least 75% of the way, merchant credits to enroll in or use before they reset); use it when the user asks what to do with their cards this quarter or what they're forgetting. Then lists the user's cards: checkout label, network, rewards currency and its value, spending caps with how much is left this period, chosen bonus categories (and whether they're current), welcome-bonus progress, progress toward yearly spend bonuses, merchant statement credits (enrolled or not, and what's left this period), which stores a store card works at, when each card's data was last verified, the point values the user saved, and (for the hosted wallet) when it was started. ${ctx.walletUse}`,
+        description: `Starts with a to-do list for the user's cards right now (bonuses to activate and their deadlines, categories to pick or confirm, caps nearly used up, welcome bonuses to finish and the weekly pace, yearly spend bonuses at least 75% of the way, statement credits to enroll in or use before they reset); use it when the user asks what to do with their cards this quarter or what they're forgetting. Then lists the user's cards: checkout label, network, rewards currency and its value, spending caps with how much is left this period, chosen bonus categories (and whether they're current), welcome-bonus progress, progress toward yearly spend bonuses, statement credits (enrolled or not, and what's left this period), which stores a store card works at, when each card's data was last verified, the point values the user saved, and (for the hosted wallet) when it was started. ${ctx.walletUse}`,
         outputSchema: WalletSummarySchema,
         annotations: {
             title: 'List wallet',
@@ -76,44 +263,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: false,
             openWorldHint: false,
         },
-    }, async () => {
-        const read = await ctx.readableWallet();
-        if (typeof read === 'string')
-            return fail(read);
-        const started = deps.savedWallets === 'account' ? await deps.store.started() : null;
-        const base = walletSummary(catalog, read.wallet, deps.today());
-        const summary = {
-            ...base,
-            started,
-            checklist: checklist(catalog, read.wallet, deps.today(), base, cardText(catalog).shortName),
-        };
-        const when = started === null
-            ? `This is ${ctx.walletName}.\n`
-            : `This is ${ctx.walletName}. ${startedText(started, Date.now())}\n`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `${when}${read.start === null ? '' : `${read.start}\n`}${formatChecklist(summary.checklist)}${formatWalletSummary(summary)}`,
-                },
-            ],
-            structuredContent: summary,
-        };
-    });
+    }, () => tools.list_wallet.run());
     server.registerTool('record_purchase', {
         title: 'Record a purchase',
-        description: `Records a purchase the user has already made, so spending caps, welcome-bonus progress, yearly spend milestones and merchant credits used stay accurate for future recommendations. It updates the user's saved wallet. Only call it after the purchase has happened, and only once per purchase: calling it twice counts the spend twice. Purchases with no cap, no open welcome bonus, no spend milestone and no enrolled merchant credit are acknowledged and nothing is written. For a merchant earnrate doesn't recognize it asks for category first, so caps aren't missed. ${ctx.walletUse}`,
-        inputSchema: z.object({
-            cardId: z
-                .string()
-                .min(1)
-                .describe('The card used, as a cardId from list_wallet or best_card_for_purchase.'),
-            merchant: Merchant,
-            amount: z.number().positive().describe('Amount spent in US dollars.'),
-            channel: ChannelInput,
-            date: DateInput,
-            category: inputs.RecordCategoryInput,
-        }),
+        description: `Records a purchase the user has already made, so spending caps, welcome-bonus progress, yearly spend bonuses and statement credits used stay accurate for future recommendations. It updates the user's saved wallet. Only call it after the purchase has happened, and only once per purchase: calling it twice counts the spend twice. Purchases with no cap, no open welcome bonus, no spend bonus and no enrolled statement credit are acknowledged and nothing is written. For a merchant earnrate doesn't recognize it asks for category first, so caps aren't missed. ${ctx.walletUse}`,
+        inputSchema: tools.record_purchase.input,
         outputSchema: RecordResultSchema,
         annotations: {
             title: 'Record a purchase',
@@ -122,57 +276,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             idempotentHint: false,
             openWorldHint: deps.llm !== null,
         },
-    }, async ({ cardId, merchant, amount, channel, date, category }) => {
-        const w = await ctx.wallet();
-        if (typeof w === 'string')
-            return fail(w);
-        if (!w.cards.some((c) => c.id === cardId))
-            return fail(`"${cardId}" isn't in the wallet. Cards: ${w.cards.map((c) => c.id).join(', ')}.`);
-        const purchase = {
-            cardId,
-            merchant,
-            amount,
-            channel: channel ?? null,
-            date: date ?? deps.today(),
-        };
-        const resolved = await ctx.resolve(merchant, purchase.channel, category ?? null);
-        if (resolved.merchant.source === 'none')
-            return fail(`earnrate doesn't recognize "${merchant}", so it can't tell which caps this purchase counts toward. Nothing was recorded. Call record_purchase again with category if you can tell what kind of business it is (a restaurant, a grocery store, a gas station), or ask the user. If nobody knows, category "other" records it toward a welcome bonus without touching any cap.`);
-        const result = await store.record(purchase, resolved.merchant);
-        if (!result.ok)
-            return fail(`Couldn't record it: ${result.error}`);
-        const { cap: booking, bonus, milestones, credit } = result;
-        const output = booking || bonus || milestones.length > 0 || credit
-            ? {
-                recorded: true,
-                booking,
-                bonus,
-                milestones,
-                credit,
-                message: `${formatBooking(amount, cardText(catalog).shortName(cardId), booking, bonus, milestones, credit)} Saved in ${ctx.walletName}.`,
-            }
-            : {
-                recorded: false,
-                booking: null,
-                bonus: null,
-                milestones: [],
-                credit: null,
-                message: `Nothing to track: ${cardText(catalog).shortName(cardId)} has no spending cap, open welcome bonus, spend milestone or enrolled merchant credit for this purchase, so the wallet wasn't changed.`,
-            };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [output.message, ...resolved.notices].join('\n'),
-                },
-            ],
-            structuredContent: output,
-        };
-    });
+    }, (args) => tools.record_purchase.run(args));
     server.registerTool('add_card', {
         title: 'Add a card',
         description: `Adds a card the user holds to their wallet by its id from search_cards, creating the wallet if there isn't one. The reply says what the card still needs (category picks, memberships, activations); ask the user about those. Stores only the card's product id and settings, never card numbers. ${ctx.walletUse}`,
-        inputSchema: CardChange,
+        inputSchema: tools.add_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Add a card',
@@ -180,19 +288,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async (args) => {
-        const result = await store.addCard(cardInput(args), deps.today());
-        const started = !result.ok || !result.created
-            ? ''
-            : deps.savedWallets === 'account'
-                ? ', the first card in your saved wallet'
-                : `, starting a new wallet at ${store.where}`;
-        return ctx.changed(result, `Added ${ctx.cardName(args.cardId)} (${args.cardId})${started}.`);
-    });
+    }, (args) => tools.add_card.run(args));
     server.registerTool('update_card', {
         title: 'Update a card',
-        description: `Changes settings on a card already in the wallet: its category picks for this period, checkout label, anniversary, opening date (optional; for first-year rates), activated categories, cap spending so far (capSpent), spending this year toward its spend milestones (milestoneSpent), merchant credits enrolled in (enrolled) and used this period (creditUsed), or a welcome bonus to track. Picks replace the saved ones in each choice group you set (other groups are kept) for the current period. Use it when the user picks new categories, such as each quarter on U.S. Bank Cash+. ${ctx.walletUse}`,
-        inputSchema: CardChange,
+        description: `Changes settings on a card already in the wallet: its category picks for this period, checkout label, anniversary, opening date (optional; for first-year rates), activated categories, cap spending so far (capSpent), spending this year toward its spend bonuses (milestoneSpent), statement credits enrolled in (enrolled) and used this period (creditUsed), or a welcome bonus to track. Picks replace the saved ones in each choice group you set (other groups are kept) for the current period. Use it when the user picks new categories, such as each quarter on U.S. Bank Cash+. ${ctx.walletUse}`,
+        inputSchema: tools.update_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Update a card',
@@ -200,18 +300,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async (args) => {
-        const what = changes(catalog, args);
-        const card = catalog.cards.find((c) => c.id === args.cardId);
-        const unused = args.anniversary !== undefined && card && !needsAnniversary(card)
-            ? " None of its caps reset on the account anniversary, so earnrate doesn't use it."
-            : '';
-        return ctx.changed(await store.updateCard(cardInput(args), deps.today()), `Updated ${ctx.cardName(args.cardId)} (${args.cardId})${what.length > 0 ? `: ${what.join('; ')}` : ''}.${unused}`);
-    });
+    }, (args) => tools.update_card.run(args));
     server.registerTool('remove_card', {
         title: 'Remove a card',
         description: `Removes a card from the wallet, with its tracked cap usage, bonus progress and yearly spending. Memberships and point values stay, even when the last card goes. Only when the user says they no longer have it or don't want it considered. ${ctx.walletUse}`,
-        inputSchema: z.object({ cardId: CardId }),
+        inputSchema: tools.remove_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Remove a card',
@@ -219,11 +312,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ cardId }) => ctx.changed(await store.removeCard(cardId), `Removed ${ctx.cardName(cardId)} (${cardId}).`, { notes: false }));
+    }, (args) => tools.remove_card.run(args));
     server.registerTool('set_memberships', {
         title: 'Set memberships',
         description: `Sets the memberships that unlock some cards' rates, such as amazon-prime for Prime Visa's 5% or a Bank of America Preferred Rewards tier, and costco for a Costco membership (so spending answers don't count its cost against Costco Anywhere). Replaces the whole list, so include the ones to keep. It saves them even with no cards saved, and every answer then uses them. ${ctx.walletUse}`,
-        inputSchema: z.object({ memberships: inputs.AllMemberships }),
+        inputSchema: tools.set_memberships.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Set memberships',
@@ -231,30 +324,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ memberships }) => {
-        const result = await store.setMemberships(memberships);
-        const used = new Set((result.ok ? result.wallet.cards : []).flatMap((held) => {
-            const card = catalog.cards.find((c) => c.id === held.id);
-            return card ? membershipsFor(card) : [];
-        }));
-        const unused = memberships.filter((m) => !used.has(m));
-        return ctx.changed(result, `${memberships.length > 0
-            ? `Memberships set to ${memberships.map((m) => `${membershipName(catalog, m)} (${m})`).join(', ')}.`
-            : 'Memberships cleared.'}${unused.length > 0 ? ` ${listed(unused.map((m) => membershipName(catalog, m)))} ${unused.length === 1 ? "doesn't" : "don't"} change any saved card's rates yet; kept for cards that use ${unused.length === 1 ? 'it' : 'them'}.` : ''}`, { notes: false });
-    });
+    }, (args) => tools.set_memberships.run(args));
     server.registerTool('set_point_values', {
         title: 'Set point values',
         description: `Saves what the user's points are worth to them, in cents per point, in their saved wallet; every answer then compares cards at those values unless a valuation profile is asked for. No saved cards are needed. Use it when the user says what their points are worth ("I value Chase points at 1.5¢") or that they transfer points to airlines and hotels (profile points-heavy). Values change only the currencies given; null goes back to earnrate's default. Currencies by id: ${catalog.currencies.map((c) => `${c.id} (${c.name})`).join(', ')}. ${ctx.walletUse}`,
-        inputSchema: z.object({
-            values: z
-                .record(z.string(), z.number().nullable())
-                .optional()
-                .describe('Cents per point by currency id, e.g. {"UR": 1.5, "MR": 1.6}. null goes back to the default.'),
-            profile: z
-                .enum(['flat', 'points-heavy'])
-                .optional()
-                .describe(`A preset: flat (${profileText('flat')}) or points-heavy (${profileText('points-heavy')}). Values given too win over it.`),
-        }),
+        inputSchema: tools.set_point_values.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Set point values',
@@ -262,22 +336,5 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ values, profile }) => {
-        const given = currencyChanges(catalog, values ?? {});
-        if (!given.ok)
-            return fail(given.error);
-        const changes = {
-            ...(profile ? VALUATION_PROFILES[profile] : {}),
-            ...given.changes,
-        };
-        if (Object.keys(changes).length === 0)
-            return fail('Give values (cents per point by currency) or a profile.');
-        const result = await store.setValuations(changes);
-        const set = Object.entries(changes).map(([id, cents]) => cents === null
-            ? `${currencyLabel(catalog, id)} back to the default`
-            : `${currencyLabel(catalog, id)} at ${String(cents)}¢`);
-        return ctx.changed(result, `Point values: ${set.join(', ')}.`, {
-            notes: false,
-        });
-    });
+    }, (args) => tools.set_point_values.run(args));
 }

package/dist/mcp/wallet-api.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { makeContext } from "./context.js";
+import { makeInputs } from "./inputs.js";
+import { importHandler } from "./tools/account.js";
+import { walletHandlers, walletListing } from "./tools/wallet.js";
+// The changes earnrate.dev can make to a synced wallet, by MCP tool name.
+// import_wallet replaces it all, with the tool's own confirmation.
+export const WALLET_CHANGES = [
+    'add_card',
+    'update_card',
+    'remove_card',
+    'set_memberships',
+    'set_point_values',
+    'record_purchase',
+    'import_wallet',
+];
+const ChangeRequest = z.object({
+    tool: z.enum(WALLET_CHANGES),
+    input: z.record(z.string(), z.unknown()).optional(),
+});
+// The hosted wallet over plain HTTP: reads give what list_wallet gives, and
+// each change runs the MCP tool's own handler, so the rules and refusals
+// can't drift between earnrate.dev and Claude.
+export function walletApi(deps) {
+    const server = {
+        ...deps,
+        savedWallets: 'account',
+        llm: null,
+        version: '',
+    };
+    const ctx = makeContext(server);
+    const handlers = {
+        ...walletHandlers(server, ctx, makeInputs(deps.catalog)),
+        import_wallet: importHandler(deps.catalog, deps.store, ctx),
+    };
+    async function read() {
+        const found = await walletListing(server, ctx);
+        if (typeof found === 'string')
+            return { status: 422, body: { error: found } };
+        return {
+            status: 200,
+            body: { wallet: found.wallet, summary: found.summary },
+        };
+    }
+    // `body` is the request's parsed JSON: {"tool": "add_card", "input": {...}}.
+    async function change(body) {
+        const request = ChangeRequest.safeParse(body);
+        if (!request.success)
+            return {
+                status: 400,
+                body: {
+                    error: `Send one change as {"tool": ..., "input": {...}}, where tool is one of ${WALLET_CHANGES.join(', ')}.`,
+                },
+            };
+        const { tool, input } = request.data;
+        const handler = handlers[tool];
+        const args = handler.input.safeParse(input ?? {});
+        if (!args.success)
+            return {
+                status: 400,
+                tool,
+                body: {
+                    error: `Invalid input for ${tool}: ${z.prettifyError(args.error)}`,
+                },
+            };
+        const result = await handler.run(args.data);
+        const text = result.content.map((c) => c.text).join('\n');
+        if (result.isError)
+            return { status: 422, tool, body: { error: text } };
+        const after = await read();
+        return {
+            status: after.status,
+            tool,
+            body: after.status === 200 ? { message: text, ...after.body } : after.body,
+        };
+    }
+    return { read, change };
+}

package/dist/schema/card.js

@@ -157,11 +157,9 @@ export const ChoiceSchema = z.strictObject({
         })),
     ])),
 });
-// A rate for a stretch after the account opens, counted from the opening
-// day: Discover's Cashback Match doubles every rate for the first 365 days,
-// Customized Cash adds 3% to its choice category. With `rules`, it changes
-// only those rules' rates, inside their caps; past a cap they earn what they
-// always do. Without, it changes every rate on the card, past caps included.
+// Counted from the opening day. With `rules`, it changes only those rules'
+// rates, inside their caps; past a cap they earn what they always do.
+// Without, it changes every rate on the card, past caps included.
 export const IntroRateSchema = z
     .strictObject({
     id: KebabId,
@@ -172,11 +170,9 @@ export const IntroRateSchema = z
     note: z.string().optional(),
 })
     .refine((i) => (i.multiply === undefined) !== (i.add === undefined), 'an intro rate needs multiply or add, not both');
-// Merchant statement credits: dollars back for spending at named merchants
-// (or a category) up to `amount` each period, like Amex Platinum's $75 a
-// quarter at lululemon. They're separate from earn rates: the purchase still
-// earns the card's rate on its whole amount, and the credit comes on top.
-// `half_year` runs January to June and July to December.
+// Separate from earn rates: the purchase still earns the card's rate on its
+// whole amount, and the credit comes on top. `half_year` runs January to June
+// and July to December.
 export const CreditPeriod = z.enum([...CapPeriod.options, 'half_year']);
 export const CreditSchema = z.strictObject({
     id: KebabId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "earnrate",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Which credit card earns the most at a merchant, from your cards or every card, and why",
   "keywords": [
     "credit cards",
@@ -54,6 +54,7 @@
     "monitor:deploy": "WRANGLER_SEND_METRICS=false wrangler deploy --config monitor/wrangler.jsonc",
     "site:build": "vite build site && node scripts/build-pages.ts",
     "site:dev": "vite site",
+    "site:preview": "yarn site:build && WRANGLER_SEND_METRICS=false wrangler deploy --config wrangler.preview.jsonc",
     "site:deploy": "yarn site:build && WRANGLER_SEND_METRICS=false wrangler deploy && node scripts/indexnow.ts",
     "test": "vitest run",
     "test:watch": "vitest",