splitwise-mcp 3.1.1 → 3.2.0

package/dist/client.js

@@ -59,6 +59,37 @@ function redactAssetQuery(err, search) {
         return err;
     return err instanceof ApiError ? new ApiError(err.status, message) : new Error(message);
 }
+/** Flatten Splitwise's `errors` value (`{field: [msg]}`, `[msg]` or a string) into messages. */
+function flattenErrors(errors) {
+    if (errors == null)
+        return [];
+    if (typeof errors === 'string')
+        return errors ? [errors] : [];
+    if (Array.isArray(errors))
+        return errors.flatMap((e) => flattenErrors(e));
+    if (typeof errors === 'object') {
+        return Object.entries(errors).flatMap(([field, value]) => flattenErrors(value).map((msg) => (field === 'base' ? msg : `${field}: ${msg}`)));
+    }
+    return [String(errors)];
+}
+/**
+ * Splitwise answers a failed write with HTTP 200, not an error status:
+ * create/update return `{expenses: [], errors: {...}}` and delete/undelete
+ * return `{success: false, errors: {...}}`. `fetchJson` only throws on
+ * non-2xx, so without this check a rejected write reaches the tool as an
+ * ordinary result and reads as "created"/"deleted". Throwing here makes every
+ * write tool report it with `isError`.
+ */
+function assertWriteSucceeded(data) {
+    if (data === null || typeof data !== 'object' || Array.isArray(data))
+        return;
+    const record = data;
+    const messages = flattenErrors(record.errors);
+    if (messages.length === 0 && record.success !== false)
+        return;
+    const detail = messages.length > 0 ? messages.join('; ') : 'success: false with no error detail';
+    throw new Error(`Splitwise rejected the request: ${detail}`);
+}
 export class SplitwiseClient {
     apiKey;
     /** Which source supplied the API key — a LABEL, never the value. */
@@ -138,7 +169,10 @@ export class SplitwiseClient {
         return this.apiKey;
     }
     async request(method, path, body) {
-        return this.api.fetchJson(method, path, body !== undefined ? { body } : {});
+        const data = await this.api.fetchJson(method, path, body !== undefined ? { body } : {});
+        if (method.toUpperCase() !== 'GET')
+            assertWriteSucceeded(data);
+        return data;
     }
     /**
      * Fetch the raw bytes behind an absolute asset URL the API handed back (an

package/dist/index.js

@@ -19,7 +19,7 @@ import { registerUtilityTools } from './tools/utilities.js';
 // client into the same registrars instead of this singleton.
 await runMcp({
     name: 'splitwise-mcp',
-    version: '3.1.1', // x-release-please-version
+    version: '3.2.0', // x-release-please-version
     deps: client,
     banner: '[splitwise-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.',
     tools: [

package/dist/tools/_confirm.js

@@ -1,21 +1,31 @@
-import { schemaConfirm, minifiedResult } from '@chrischall/mcp-utils';
-export { schemaConfirm };
+import { confirmationFromEnv, confirmTokenParam, requireConfirmationWithFallback, } from '@chrischall/mcp-utils';
+export { confirmTokenParam };
+/** The sentence every gated tool's description ends with. */
+export const CONFIRM_NOTE = 'Asks the user to confirm first: a confirmation prompt where the client supports one; otherwise the first call returns a preview and a confirmToken, and only a repeat call with that token proceeds (see MCP_CONFIRM_MODE).';
 /**
- * Confirm-gate for a mutating tool (the fleet convention). When `confirm` is not
- * `true`, returns a no-network dry-run preview of exactly what would be sent;
- * when it is `true`, returns `null` so the caller proceeds with the write.
- * Splitwise writes notify other people (friends / group members), so a single
- * hallucinated call shouldn't fire silently.
+ * Confirm-gate for a mutating tool. Splitwise writes notify other people
+ * (friends / group members), so a single hallucinated call shouldn't fire
+ * silently.
+ *
+ * A client that can show a prompt is asked; one that cannot gets the two-step
+ * token flow (`MCP_CONFIRM_MODE`): the first call does nothing and returns the
+ * preview below plus a confirmToken bound to exactly this request, and only a
+ * repeat call with that token proceeds. `undefined` means proceed; anything
+ * else is the result to return unchanged.
  */
-export function previewUnlessConfirmed(confirm, action, method, path, body) {
-    if (confirm === true)
-        return null;
-    return minifiedResult({
-        dryRun: true,
-        action,
-        method,
-        path,
-        ...(body !== undefined ? { willSend: body } : {}),
-        note: 'Re-run with confirm: true to execute.',
-    });
+export function confirmWrite(ctx, gate) {
+    const request = {
+        method: gate.method,
+        path: gate.path,
+        ...(gate.body !== undefined ? { willSend: gate.body } : {}),
+    };
+    const preview = { action: gate.summary, ...request };
+    return requireConfirmationWithFallback(ctx, confirmationFromEnv({
+        action: gate.action,
+        message: `Review and confirm: ${gate.summary}`,
+        details: preview,
+        tool: gate.tool,
+        confirmToken: gate.confirmToken,
+        subject: () => ({ target: String(gate.target), payload: request, preview }),
+    }));
 }

package/dist/tools/expenses.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { SW_VIEWS, viewExpense, viewExpenses } from '../project.js';
 import { buildQueryString, minifiedResult, resolveView, viewParam } from '@chrischall/mcp-utils';
-import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { CONFIRM_NOTE, confirmTokenParam, confirmWrite } from './_confirm.js';
 /** Flattens a users array into Splitwise's flat-param JSON format. */
 export function flattenUsers(users) {
     const flat = {};
@@ -13,8 +13,8 @@ export function flattenUsers(users) {
     return flat;
 }
 function buildExpenseBody(args) {
-    // `confirm` is a tool-gate flag, not part of the Splitwise expense payload.
-    const { split_equally, users, expense_id: _id, confirm: _confirm, ...rest } = args;
+    // `confirmToken` is a tool-gate input, not part of the Splitwise expense payload.
+    const { split_equally, users, expense_id: _id, confirmToken: _confirmToken, ...rest } = args;
     if (split_equally && users) {
         throw new Error('Provide either split_equally or users, not both');
     }
@@ -83,7 +83,7 @@ export function registerExpenseTools(server, client) {
         return minifiedResult(viewExpense(resolveView(view, SW_VIEWS), data));
     });
     server.registerTool('sw_create_expense', {
-        description: 'Create a Splitwise expense. Use split_equally:true to split evenly among group members, or provide a users array for custom per-person splits (paid_share and owed_share as decimal strings like "25.00"). cost must be a decimal string. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it creates the expense.',
+        description: `Create a Splitwise expense. Use split_equally:true to split evenly among group members, or provide a users array for custom per-person splits (paid_share and owed_share as decimal strings like "25.00"). cost must be a decimal string. ${CONFIRM_NOTE}`,
         inputSchema: z.object({
             group_id: z.number().describe('Group to add expense to (use 0 for no group)'),
             description: z.string().describe('Short description of the expense'),
@@ -103,18 +103,27 @@ export function registerExpenseTools(server, client) {
             date: z.string().describe('ISO 8601 datetime').optional(),
             category_id: z.number().describe('Category id from sw_get_categories').optional(),
             details: z.string().describe('Notes').optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async (args) => {
+    }, async (args, ctx) => {
         const body = buildExpenseBody(args);
-        const gate = previewUnlessConfirmed(args.confirm, `Create a Splitwise expense "${args.description}" (${args.cost}) — notifies group members`, 'POST', '/create_expense', body);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_create_expense',
+            action: 'expense.create',
+            summary: `Create a Splitwise expense "${args.description}" (${args.cost}) — notifies group members`,
+            method: 'POST',
+            path: '/create_expense',
+            body,
+            target: args.group_id,
+            confirmToken: args.confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/create_expense', body);
         return minifiedResult(data);
     });
     server.registerTool('sw_update_expense', {
-        description: 'Edit an existing Splitwise expense. Provide expense_id and any fields to change. For custom split updates, the full users array must be provided (the API replaces the entire split). Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it updates the expense.',
+        description: `Edit an existing Splitwise expense. Provide expense_id and any fields to change. For custom split updates, the full users array must be provided (the API replaces the entire split). ${CONFIRM_NOTE}`,
         inputSchema: z.object({
             expense_id: z.number().describe('ID of the expense to update'),
             description: z.string().optional(),
@@ -128,26 +137,43 @@ export function registerExpenseTools(server, client) {
             date: z.string().optional(),
             category_id: z.number().optional(),
             details: z.string().optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async (args) => {
+    }, async (args, ctx) => {
         const { expense_id } = args;
         const body = buildExpenseBody(args);
-        const gate = previewUnlessConfirmed(args.confirm, `Update Splitwise expense ${expense_id} — notifies group members`, 'POST', `/update_expense/${expense_id}`, body);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_update_expense',
+            action: 'expense.update',
+            summary: `Update Splitwise expense ${expense_id} — notifies group members`,
+            method: 'POST',
+            path: `/update_expense/${expense_id}`,
+            body,
+            target: expense_id,
+            confirmToken: args.confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/update_expense/${expense_id}`, body);
         return minifiedResult(data);
     });
     server.registerTool('sw_delete_expense', {
-        description: 'Soft-delete a Splitwise expense by id. Returns {success: true} on success. Use sw_undelete_expense to restore. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it deletes.',
+        description: `Soft-delete a Splitwise expense by id. Returns {success: true} on success. Use sw_undelete_expense to restore. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             id: z.number().describe('Expense ID to delete'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ id, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Soft-delete Splitwise expense ${id}`, 'POST', `/delete_expense/${id}`);
+    }, async ({ id, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_delete_expense',
+            action: 'expense.delete',
+            summary: `Soft-delete Splitwise expense ${id}`,
+            method: 'POST',
+            path: `/delete_expense/${id}`,
+            target: id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/delete_expense/${id}`);

package/dist/tools/friends.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { PERSON_VIEW_NOTE, SW_VIEWS, viewFriends } from '../project.js';
 import { minifiedResult, pruneUndefined, resolveView, viewParam } from '@chrischall/mcp-utils';
-import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { CONFIRM_NOTE, confirmTokenParam, confirmWrite } from './_confirm.js';
 export function registerFriendTools(server, client) {
     server.registerTool('sw_list_friends', {
         description: "List all Splitwise friends. Use this to resolve a friend's name to a user_id before adding them to a group or building a custom expense split. The compact default returns id, name (first_name + last_name joined), email, registration_status and any non-empty balance per friend; pass view:'full' for Splitwise's raw records, which keep first_name and last_name separate.",
@@ -14,31 +14,48 @@ export function registerFriendTools(server, client) {
         return minifiedResult(viewFriends(resolveView(view, SW_VIEWS), data));
     });
     server.registerTool('sw_create_friend', {
-        description: 'Add a Splitwise friend by email (sends them an invite). Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it adds the friend.',
+        description: `Add a Splitwise friend by email (sends them an invite). ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             user_email: z.string().describe('Email of the user to add as a friend'),
             user_first_name: z.string().describe('First name of the user').optional(),
             user_last_name: z.string().describe('Last name of the user').optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ user_email, user_first_name, user_last_name, confirm }) => {
+    }, async ({ user_email, user_first_name, user_last_name, confirmToken }, ctx) => {
         const body = pruneUndefined({ user_email, user_first_name, user_last_name });
-        const gate = previewUnlessConfirmed(confirm, `Add ${user_email} as a Splitwise friend`, 'POST', '/create_friend', body);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_create_friend',
+            action: 'friend.create',
+            summary: `Add ${user_email} as a Splitwise friend`,
+            method: 'POST',
+            path: '/create_friend',
+            body,
+            target: user_email,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/create_friend', body);
         return minifiedResult(data);
     });
     server.registerTool('sw_delete_friend', {
-        description: 'Remove a Splitwise friendship by user id. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it removes the friendship.',
+        description: `Remove a Splitwise friendship by user id. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             id: z.number().describe('User ID of the friend to remove'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ id, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Remove Splitwise friendship with user ${id}`, 'POST', `/delete_friend/${id}`);
+    }, async ({ id, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_delete_friend',
+            action: 'friend.delete',
+            summary: `Remove Splitwise friendship with user ${id}`,
+            method: 'POST',
+            path: `/delete_friend/${id}`,
+            target: id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/delete_friend/${id}`);

package/dist/tools/groups.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { SW_VIEWS, viewGroup, viewGroups } from '../project.js';
 import { minifiedResult, pruneUndefined, resolveView, viewParam } from '@chrischall/mcp-utils';
-import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { CONFIRM_NOTE, confirmTokenParam, confirmWrite } from './_confirm.js';
 export function registerGroupTools(server, client) {
     server.registerTool('sw_list_groups', {
         description: 'List all Splitwise groups the current user belongs to. Returns id, name, and members for each group. Use this to resolve a group name to its id.',
@@ -29,7 +29,7 @@ export function registerGroupTools(server, client) {
         return minifiedResult(viewGroup(resolveView(view, SW_VIEWS), data));
     });
     server.registerTool('sw_create_group', {
-        description: 'Create a new Splitwise group.',
+        description: `Create a new Splitwise group. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             name: z.string().describe('Group name'),
@@ -41,27 +41,36 @@ export function registerGroupTools(server, client) {
                 .boolean()
                 .describe('Whether to simplify debts by default')
                 .optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ name, group_type, simplify_by_default, confirm }) => {
+    }, async ({ name, group_type, simplify_by_default, confirmToken }, ctx) => {
         const body = pruneUndefined({ name, group_type, simplify_by_default });
-        const gate = previewUnlessConfirmed(confirm, `Create Splitwise group "${name}"`, 'POST', '/create_group', body);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_create_group',
+            action: 'group.create',
+            summary: `Create Splitwise group "${name}"`,
+            method: 'POST',
+            path: '/create_group',
+            body,
+            target: '',
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/create_group', body);
         return minifiedResult(data);
     });
     server.registerTool('sw_add_user_to_group', {
-        description: 'Add a user to a Splitwise group. Provide user_id (preferred, use sw_list_friends to resolve a name) or first_name + last_name + email to invite by email.',
+        description: `Add a user to a Splitwise group. Provide user_id (preferred, use sw_list_friends to resolve a name) or first_name + last_name + email to invite by email. ${CONFIRM_NOTE}`,
         inputSchema: z.object({
             group_id: z.number().describe('Group ID'),
             user_id: z.number().describe('User ID (preferred)').optional(),
             first_name: z.string().optional(),
             last_name: z.string().optional(),
             email: z.string().optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ group_id, user_id, first_name, last_name, email, confirm }) => {
+    }, async ({ group_id, user_id, first_name, last_name, email, confirmToken }, ctx) => {
         let body;
         if (user_id !== undefined) {
             body = { group_id, user_id };
@@ -72,36 +81,62 @@ export function registerGroupTools(server, client) {
             }
             body = { group_id, first_name, last_name, email };
         }
-        const gate = previewUnlessConfirmed(confirm, `Add a user to Splitwise group ${group_id} (may send an invite email)`, 'POST', '/add_user_to_group', body);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_add_user_to_group',
+            action: 'group.add_user',
+            summary: `Add a user to Splitwise group ${group_id} (may send an invite email)`,
+            method: 'POST',
+            path: '/add_user_to_group',
+            body,
+            target: group_id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/add_user_to_group', body);
         return minifiedResult(data);
     });
     server.registerTool('sw_remove_user_from_group', {
-        description: 'Remove a user from a Splitwise group. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it removes the user.',
+        description: `Remove a user from a Splitwise group. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             group_id: z.number().describe('Group ID'),
             user_id: z.number().describe('User ID to remove'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ group_id, user_id, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Remove user ${user_id} from Splitwise group ${group_id}`, 'POST', '/remove_user_from_group', { group_id, user_id });
+    }, async ({ group_id, user_id, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_remove_user_from_group',
+            action: 'group.remove_user',
+            summary: `Remove user ${user_id} from Splitwise group ${group_id}`,
+            method: 'POST',
+            path: '/remove_user_from_group',
+            body: { group_id, user_id },
+            target: group_id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/remove_user_from_group', { group_id, user_id });
         return minifiedResult(data);
     });
     server.registerTool('sw_delete_group', {
-        description: 'Soft-delete a Splitwise group. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it deletes.',
+        description: `Soft-delete a Splitwise group. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             id: z.number().describe('Group ID to delete'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ id, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Soft-delete Splitwise group ${id}`, 'POST', `/delete_group/${id}`);
+    }, async ({ id, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_delete_group',
+            action: 'group.delete',
+            summary: `Soft-delete Splitwise group ${id}`,
+            method: 'POST',
+            path: `/delete_group/${id}`,
+            target: id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/delete_group/${id}`);

package/dist/tools/user.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { PERSON_VIEW_NOTE, SW_VIEWS, viewUser } from '../project.js';
 import { minifiedResult, pruneUndefined, resolveView, viewParam } from '@chrischall/mcp-utils';
-import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { CONFIRM_NOTE, confirmTokenParam, confirmWrite } from './_confirm.js';
 export function registerUserTools(server, client) {
     server.registerTool('sw_get_current_user', {
         description: "Get the authenticated Splitwise user's profile. Use the returned id when building custom expense splits. The compact default returns id, name (first_name + last_name joined), email and registration_status; pass view:'full' for Splitwise's raw record, which keeps first_name and last_name separate — the form sw_update_user takes.",
@@ -25,29 +25,39 @@ export function registerUserTools(server, client) {
         return minifiedResult(viewUser(resolveView(view, SW_VIEWS), data));
     });
     server.registerTool('sw_update_user', {
-        description: "Update the current user's profile fields. id must be the current user's id.",
+        description: "Update the current user's profile fields: name, locale and default currency. id must be the current user's id. The login email and password are deliberately not settable here — account credentials are changed in the Splitwise app, not by an assistant. " + CONFIRM_NOTE,
+        annotations: { readOnlyHint: false, destructiveHint: true },
+        // No `email` / `password`: changing the login email is an account
+        // takeover primitive (a password reset to the new address follows), and
+        // the only gate would be a model-driven confirmation that injected text from
+        // comments, notifications or receipts could talk it into (fleet-audit
+        // #250). z.object strips unknown keys, so a caller passing them anyway
+        // has them dropped before the request is built.
         inputSchema: z.object({
             id: z.number().describe("User ID (must be the current user's id)"),
             first_name: z.string().optional(),
             last_name: z.string().optional(),
-            email: z.string().optional(),
-            password: z.string().optional(),
             locale: z.string().optional(),
             default_currency: z.string().optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ id, first_name, last_name, email, password, locale, default_currency, confirm }) => {
+    }, async ({ id, first_name, last_name, locale, default_currency, confirmToken }, ctx) => {
         const body = pruneUndefined({
             first_name,
             last_name,
-            email,
-            password,
             locale,
             default_currency,
         });
-        // Never echo the password in the dry-run preview.
-        const previewBody = { ...body, ...(password !== undefined ? { password: '[hidden]' } : {}) };
-        const gate = previewUnlessConfirmed(confirm, `Update current Splitwise user ${id} profile`, 'POST', `/update_user/${id}`, previewBody);
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_update_user',
+            action: 'user.update',
+            summary: `Update current Splitwise user ${id} profile`,
+            method: 'POST',
+            path: `/update_user/${id}`,
+            body,
+            target: id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/update_user/${id}`, body);

package/dist/tools/utilities.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { SW_VIEWS, viewGeneric } from '../project.js';
 import { buildQueryString, minifiedResult, resolveView, viewParam } from '@chrischall/mcp-utils';
-import { previewUnlessConfirmed, schemaConfirm } from './_confirm.js';
+import { CONFIRM_NOTE, confirmTokenParam, confirmWrite } from './_confirm.js';
 export function registerUtilityTools(server, client) {
     server.registerTool('sw_get_notifications', {
         description: 'Get recent Splitwise activity notifications for the current user.',
@@ -45,29 +45,46 @@ export function registerUtilityTools(server, client) {
         return minifiedResult(viewGeneric(resolveView(view, SW_VIEWS), data));
     });
     server.registerTool('sw_create_comment', {
-        description: 'Add a comment to a Splitwise expense (visible to other participants). Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it posts.',
+        description: `Add a comment to a Splitwise expense (visible to other participants). ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             expense_id: z.number().describe('Expense ID to comment on'),
             content: z.string().describe('Comment text'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ expense_id, content, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Comment on Splitwise expense ${expense_id} (visible to participants)`, 'POST', '/create_comment', { expense_id, content });
+    }, async ({ expense_id, content, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_create_comment',
+            action: 'comment.create',
+            summary: `Comment on Splitwise expense ${expense_id} (visible to participants)`,
+            method: 'POST',
+            path: '/create_comment',
+            body: { expense_id, content },
+            target: expense_id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', '/create_comment', { expense_id, content });
         return minifiedResult(data);
     });
     server.registerTool('sw_delete_comment', {
-        description: 'Delete a comment by id. Without confirm:true this returns a dry-run preview and makes NO network call; with confirm:true it deletes.',
+        description: `Delete a comment by id. ${CONFIRM_NOTE}`,
         annotations: { destructiveHint: true },
         inputSchema: z.object({
             id: z.number().describe('Comment ID to delete'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ id, confirm }) => {
-        const gate = previewUnlessConfirmed(confirm, `Delete Splitwise comment ${id}`, 'POST', `/delete_comment/${id}`);
+    }, async ({ id, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'sw_delete_comment',
+            action: 'comment.delete',
+            summary: `Delete Splitwise comment ${id}`,
+            method: 'POST',
+            path: `/delete_comment/${id}`,
+            target: id,
+            confirmToken,
+        });
         if (gate)
             return gate;
         const data = await client.request('POST', `/delete_comment/${id}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "splitwise-mcp",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "mcpName": "io.github.chrischall/splitwise-mcp",
   "description": "Splitwise MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -45,7 +45,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^2.4.0",
+    "@chrischall/mcp-utils": "^2.6.0",
     "@modelcontextprotocol/server": "^2.0.0",
     "dotenv": "^17.4.0",
     "unpdf": "^1.8.1",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/splitwise-mcp",
     "source": "github"
   },
-  "version": "3.1.1",
+  "version": "3.2.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "splitwise-mcp",
-      "version": "3.1.1",
+      "version": "3.2.0",
       "transport": {
         "type": "stdio"
       },

package/skills/splitwise-mcp/SKILL.md

@@ -221,6 +221,7 @@ sw_update_expense(expense_id, description: "Corrected description", cost: "95.00
 
 ## Notes
 
+- Every write except `sw_undelete_expense` / `sw_undelete_group` asks the user to confirm first. Where the client can show a prompt, it does. Otherwise the first call changes nothing and returns `status: "confirmation-required"` with a `preview` (method, path, `willSend`) and a `confirmToken`: show the preview to the user, get their approval in chat, then repeat the same call with the same arguments plus `confirmToken` (see `MCP_CONFIRM_MODE`). A token acts once, expires, and is refused (`DRAFT_CHANGED`) if any argument changed
 - `cost` is always a decimal string (e.g. `"25.00"`)
 - `split_equally: true` and `users` array are mutually exclusive
 - For custom split updates, the **full `users` array is required** — the API replaces the entire split