splitwise-mcp 1.3.0 → 2.0.1

package/dist/index.js

@@ -1,54 +1,19 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { SplitwiseClient } from './client.js';
-import { toolDefinitions as userTools, handleTool as handleUser } from './tools/user.js';
-import { toolDefinitions as groupTools, handleTool as handleGroups } from './tools/groups.js';
-import { toolDefinitions as friendTools, handleTool as handleFriends } from './tools/friends.js';
-import { toolDefinitions as expenseTools, handleTool as handleExpenses } from './tools/expenses.js';
-import { toolDefinitions as utilityTools, handleTool as handleUtilities } from './tools/utilities.js';
+import { registerUserTools } from './tools/user.js';
+import { registerGroupTools } from './tools/groups.js';
+import { registerFriendTools } from './tools/friends.js';
+import { registerExpenseTools } from './tools/expenses.js';
+import { registerUtilityTools } from './tools/utilities.js';
 const client = new SplitwiseClient();
-const allTools = [
-    ...userTools,
-    ...groupTools,
-    ...friendTools,
-    ...expenseTools,
-    ...utilityTools,
-];
-const handlers = {};
-for (const tool of userTools)
-    handlers[tool.name] = (n, a) => handleUser(n, a, client);
-for (const tool of groupTools)
-    handlers[tool.name] = (n, a) => handleGroups(n, a, client);
-for (const tool of friendTools)
-    handlers[tool.name] = (n, a) => handleFriends(n, a, client);
-for (const tool of expenseTools)
-    handlers[tool.name] = (n, a) => handleExpenses(n, a, client);
-for (const tool of utilityTools)
-    handlers[tool.name] = (n, a) => handleUtilities(n, a, client);
-const server = new Server({ name: 'splitwise-mcp', version: '1.2.0' }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    const handler = handlers[name];
-    if (!handler) {
-        return {
-            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-            isError: true,
-        };
-    }
-    try {
-        return await handler(name, args);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: 'text', text: `Error: ${message}` }],
-            isError: true,
-        };
-    }
-});
+const server = new McpServer({ name: 'splitwise-mcp', version: '2.0.2' });
+registerUserTools(server, client);
+registerGroupTools(server, client);
+registerFriendTools(server, client);
+registerExpenseTools(server, client);
+registerUtilityTools(server, client);
 console.error('[splitwise-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.');
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools/expenses.js

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 /** Flattens a users array into Splitwise's flat-param JSON format. */
 export function flattenUsers(users) {
     const flat = {};
@@ -22,164 +23,101 @@ function buildExpenseBody(args) {
     }
     return body;
 }
-export const toolDefinitions = [
-    {
-        name: 'sw_list_expenses',
+const userShareSchema = z.object({
+    user_id: z.number(),
+    paid_share: z.string().describe('Amount this user paid, e.g. "25.00"'),
+    owed_share: z.string().describe('Amount this user owes, e.g. "12.50"'),
+});
+export function registerExpenseTools(server, client) {
+    server.registerTool('sw_list_expenses', {
         description: 'List or search Splitwise expenses. All filters are optional. Use group_id to filter by group, dated_after/dated_before for date ranges.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                group_id: { type: 'integer', description: 'Only expenses in this group' },
-                friend_id: { type: 'integer', description: 'Only expenses with this friend' },
-                dated_after: { type: 'string', description: 'ISO 8601 date — only expenses on or after this date' },
-                dated_before: { type: 'string', description: 'ISO 8601 date — only expenses on or before this date' },
-                updated_after: { type: 'string', description: 'ISO 8601 datetime' },
-                updated_before: { type: 'string', description: 'ISO 8601 datetime' },
-                limit: { type: 'integer', description: 'Max results (API default: 20)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-            },
-            required: [],
+            group_id: z.number().describe('Only expenses in this group').optional(),
+            friend_id: z.number().describe('Only expenses with this friend').optional(),
+            dated_after: z.string().describe('ISO 8601 date — only expenses on or after this date').optional(),
+            dated_before: z.string().describe('ISO 8601 date — only expenses on or before this date').optional(),
+            updated_after: z.string().describe('ISO 8601 datetime').optional(),
+            updated_before: z.string().describe('ISO 8601 datetime').optional(),
+            limit: z.number().describe('Max results (API default: 20)').optional(),
+            offset: z.number().describe('Pagination offset').optional(),
         },
-    },
-    {
-        name: 'sw_get_expense',
+    }, async (args) => {
+        const params = new URLSearchParams();
+        const filters = ['group_id', 'friend_id', 'dated_after', 'dated_before', 'updated_after', 'updated_before', 'limit', 'offset'];
+        for (const key of filters) {
+            const val = args[key];
+            if (val !== undefined)
+                params.append(key, String(val));
+        }
+        const qs = params.toString();
+        const data = await client.request('GET', qs ? `/get_expenses?${qs}` : '/get_expenses');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_get_expense', {
         description: 'Get full details of a single Splitwise expense by id.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Expense ID' },
-            },
-            required: ['id'],
+            id: z.number().describe('Expense ID'),
         },
-    },
-    {
-        name: 'sw_create_expense',
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/get_expense/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    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.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                group_id: { type: 'integer', description: 'Group to add expense to (use 0 for no group)' },
-                description: { type: 'string', description: 'Short description of the expense' },
-                cost: { type: 'string', description: 'Total cost as decimal string, e.g. "25.00"' },
-                split_equally: { type: 'boolean', description: 'Split equally among group members (mutually exclusive with users)' },
-                users: {
-                    type: 'array',
-                    description: 'Custom split (mutually exclusive with split_equally). Full list of participants required.',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            user_id: { type: 'integer' },
-                            paid_share: { type: 'string', description: 'Amount this user paid, e.g. "25.00"' },
-                            owed_share: { type: 'string', description: 'Amount this user owes, e.g. "12.50"' },
-                        },
-                        required: ['user_id', 'paid_share', 'owed_share'],
-                    },
-                },
-                currency_code: { type: 'string', description: 'Currency code, e.g. "USD". Defaults to group/user default.' },
-                date: { type: 'string', description: 'ISO 8601 datetime' },
-                category_id: { type: 'integer', description: 'Category id from sw_get_categories' },
-                details: { type: 'string', description: 'Notes' },
-            },
-            required: ['group_id', 'description', 'cost'],
+            group_id: z.number().describe('Group to add expense to (use 0 for no group)'),
+            description: z.string().describe('Short description of the expense'),
+            cost: z.string().describe('Total cost as decimal string, e.g. "25.00"'),
+            split_equally: z.boolean().describe('Split equally among group members (mutually exclusive with users)').optional(),
+            users: z.array(userShareSchema).describe('Custom split (mutually exclusive with split_equally). Full list of participants required.').optional(),
+            currency_code: z.string().describe('Currency code, e.g. "USD". Defaults to group/user default.').optional(),
+            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(),
         },
-    },
-    {
-        name: 'sw_update_expense',
+    }, async (args) => {
+        const body = buildExpenseBody(args);
+        const data = await client.request('POST', '/create_expense', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    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).',
         inputSchema: {
-            type: 'object',
-            properties: {
-                expense_id: { type: 'integer', description: 'ID of the expense to update' },
-                description: { type: 'string' },
-                cost: { type: 'string', description: 'Decimal string, e.g. "25.00"' },
-                split_equally: { type: 'boolean', description: 'Mutually exclusive with users' },
-                users: {
-                    type: 'array',
-                    description: 'Full replacement split — all users must be included. Mutually exclusive with split_equally.',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            user_id: { type: 'integer' },
-                            paid_share: { type: 'string' },
-                            owed_share: { type: 'string' },
-                        },
-                        required: ['user_id', 'paid_share', 'owed_share'],
-                    },
-                },
-                currency_code: { type: 'string' },
-                date: { type: 'string' },
-                category_id: { type: 'integer' },
-                details: { type: 'string' },
-            },
-            required: ['expense_id'],
+            expense_id: z.number().describe('ID of the expense to update'),
+            description: z.string().optional(),
+            cost: z.string().describe('Decimal string, e.g. "25.00"').optional(),
+            split_equally: z.boolean().describe('Mutually exclusive with users').optional(),
+            users: z.array(userShareSchema).describe('Full replacement split — all users must be included. Mutually exclusive with split_equally.').optional(),
+            currency_code: z.string().optional(),
+            date: z.string().optional(),
+            category_id: z.number().optional(),
+            details: z.string().optional(),
         },
-    },
-    {
-        name: 'sw_delete_expense',
+    }, async (args) => {
+        const { expense_id } = args;
+        const body = buildExpenseBody(args);
+        const data = await client.request('POST', `/update_expense/${expense_id}`, body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_delete_expense', {
         description: 'Soft-delete a Splitwise expense by id. Returns {success: true} on success. Use sw_undelete_expense to restore.',
         annotations: { destructiveHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Expense ID to delete' },
-            },
-            required: ['id'],
+            id: z.number().describe('Expense ID to delete'),
         },
-    },
-    {
-        name: 'sw_undelete_expense',
+    }, async ({ id }) => {
+        const data = await client.request('POST', `/delete_expense/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_undelete_expense', {
         description: 'Restore a soft-deleted Splitwise expense.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Expense ID to restore' },
-            },
-            required: ['id'],
+            id: z.number().describe('Expense ID to restore'),
         },
-    },
-];
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'sw_list_expenses': {
-            const params = new URLSearchParams();
-            const filters = ['group_id', 'friend_id', 'dated_after', 'dated_before', 'updated_after', 'updated_before', 'limit', 'offset'];
-            for (const key of filters) {
-                if (args[key] !== undefined)
-                    params.append(key, String(args[key]));
-            }
-            const qs = params.toString();
-            const data = await client.request('GET', qs ? `/get_expenses?${qs}` : '/get_expenses');
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_get_expense': {
-            const { id } = args;
-            const data = await client.request('GET', `/get_expense/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_create_expense': {
-            const body = buildExpenseBody(args);
-            const data = await client.request('POST', '/create_expense', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_update_expense': {
-            const { expense_id } = args;
-            const body = buildExpenseBody(args);
-            const data = await client.request('POST', `/update_expense/${expense_id}`, body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_delete_expense': {
-            const { id } = args;
-            const data = await client.request('POST', `/delete_expense/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_undelete_expense': {
-            const { id } = args;
-            const data = await client.request('POST', `/undelete_expense/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ id }) => {
+        const data = await client.request('POST', `/undelete_expense/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/friends.js

@@ -1,58 +1,36 @@
-export const toolDefinitions = [
-    {
-        name: 'sw_list_friends',
-        description: 'List all Splitwise friends with their id, first_name, last_name, and email. Use this to resolve a friend\'s name to a user_id before adding them to a group or building a custom expense split.',
+import { z } from 'zod';
+export function registerFriendTools(server, client) {
+    server.registerTool('sw_list_friends', {
+        description: "List all Splitwise friends with their id, first_name, last_name, and email. Use this to resolve a friend's name to a user_id before adding them to a group or building a custom expense split.",
         annotations: { readOnlyHint: true },
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'sw_create_friend',
+    }, async () => {
+        const data = await client.request('GET', '/get_friends');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_create_friend', {
         description: 'Add a Splitwise friend by email.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                user_email: { type: 'string', description: 'Email of the user to add as a friend' },
-                user_first_name: { type: 'string', description: 'First name of the user' },
-                user_last_name: { type: 'string', description: 'Last name of the user' },
-            },
-            required: ['user_email'],
+            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(),
         },
-    },
-    {
-        name: 'sw_delete_friend',
+    }, async ({ user_email, user_first_name, user_last_name }) => {
+        const body = { user_email };
+        if (user_first_name !== undefined)
+            body.user_first_name = user_first_name;
+        if (user_last_name !== undefined)
+            body.user_last_name = user_last_name;
+        const data = await client.request('POST', '/create_friend', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_delete_friend', {
         description: 'Remove a Splitwise friendship by user id.',
         annotations: { destructiveHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'User ID of the friend to remove' },
-            },
-            required: ['id'],
+            id: z.number().describe('User ID of the friend to remove'),
         },
-    },
-];
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'sw_list_friends': {
-            const data = await client.request('GET', '/get_friends');
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_create_friend': {
-            const { user_email, user_first_name, user_last_name } = args;
-            const body = { user_email };
-            if (user_first_name !== undefined)
-                body.user_first_name = user_first_name;
-            if (user_last_name !== undefined)
-                body.user_last_name = user_last_name;
-            const data = await client.request('POST', '/create_friend', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_delete_friend': {
-            const { id } = args;
-            const data = await client.request('POST', `/delete_friend/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ id }) => {
+        const data = await client.request('POST', `/delete_friend/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/groups.js

@@ -1,142 +1,88 @@
-export const toolDefinitions = [
-    {
-        name: 'sw_list_groups',
+import { z } from 'zod';
+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.',
         annotations: { readOnlyHint: true },
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'sw_get_group',
+    }, async () => {
+        const data = await client.request('GET', '/get_groups');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_get_group', {
         description: 'Get details of a single Splitwise group including all members and balances.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Group ID' },
-            },
-            required: ['id'],
+            id: z.number().describe('Group ID'),
         },
-    },
-    {
-        name: 'sw_create_group',
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/get_group/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_create_group', {
         description: 'Create a new Splitwise group.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-                group_type: {
-                    type: 'string',
-                    enum: ['apartment', 'house', 'trip', 'other'],
-                    description: 'Type of group',
-                },
-                simplify_by_default: { type: 'boolean', description: 'Whether to simplify debts by default' },
-            },
-            required: ['name'],
+            name: z.string().describe('Group name'),
+            group_type: z.enum(['apartment', 'house', 'trip', 'other']).describe('Type of group').optional(),
+            simplify_by_default: z.boolean().describe('Whether to simplify debts by default').optional(),
         },
-    },
-    {
-        name: '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.',
+    }, async ({ name, group_type, simplify_by_default }) => {
+        const body = { name };
+        if (group_type !== undefined)
+            body.group_type = group_type;
+        if (simplify_by_default !== undefined)
+            body.simplify_by_default = simplify_by_default;
+        const data = await client.request('POST', '/create_group', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    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.",
         inputSchema: {
-            type: 'object',
-            properties: {
-                group_id: { type: 'integer', description: 'Group ID' },
-                user_id: { type: 'integer', description: 'User ID (preferred)' },
-                first_name: { type: 'string' },
-                last_name: { type: 'string' },
-                email: { type: 'string' },
-            },
-            required: ['group_id'],
+            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(),
         },
-    },
-    {
-        name: 'sw_remove_user_from_group',
+    }, async ({ group_id, user_id, first_name, last_name, email }) => {
+        let body;
+        if (user_id !== undefined) {
+            body = { group_id, user_id };
+        }
+        else {
+            if (!first_name || !last_name || !email) {
+                throw new Error('first_name, last_name, and email are required when user_id is not provided');
+            }
+            body = { group_id, first_name, last_name, email };
+        }
+        const data = await client.request('POST', '/add_user_to_group', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_remove_user_from_group', {
         description: 'Remove a user from a Splitwise group.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                group_id: { type: 'integer', description: 'Group ID' },
-                user_id: { type: 'integer', description: 'User ID to remove' },
-            },
-            required: ['group_id', 'user_id'],
+            group_id: z.number().describe('Group ID'),
+            user_id: z.number().describe('User ID to remove'),
         },
-    },
-    {
-        name: 'sw_delete_group',
+    }, async ({ group_id, user_id }) => {
+        const data = await client.request('POST', '/remove_user_from_group', { group_id, user_id });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_delete_group', {
         description: 'Soft-delete a Splitwise group.',
         annotations: { destructiveHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Group ID to delete' },
-            },
-            required: ['id'],
+            id: z.number().describe('Group ID to delete'),
         },
-    },
-    {
-        name: 'sw_undelete_group',
+    }, async ({ id }) => {
+        const data = await client.request('POST', `/delete_group/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('sw_undelete_group', {
         description: 'Restore a soft-deleted Splitwise group.',
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Group ID to restore' },
-            },
-            required: ['id'],
+            id: z.number().describe('Group ID to restore'),
         },
-    },
-];
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'sw_list_groups': {
-            const data = await client.request('GET', '/get_groups');
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_get_group': {
-            const { id } = args;
-            const data = await client.request('GET', `/get_group/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_create_group': {
-            const { name, group_type, simplify_by_default } = args;
-            const body = { name };
-            if (group_type !== undefined)
-                body.group_type = group_type;
-            if (simplify_by_default !== undefined)
-                body.simplify_by_default = simplify_by_default;
-            const data = await client.request('POST', '/create_group', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_add_user_to_group': {
-            const { group_id, user_id, first_name, last_name, email } = args;
-            let body;
-            if (user_id !== undefined) {
-                body = { group_id, user_id };
-            }
-            else {
-                if (!first_name || !last_name || !email) {
-                    throw new Error('first_name, last_name, and email are required when user_id is not provided');
-                }
-                body = { group_id, first_name, last_name, email };
-            }
-            const data = await client.request('POST', '/add_user_to_group', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_remove_user_from_group': {
-            const { group_id, user_id } = args;
-            const data = await client.request('POST', '/remove_user_from_group', { group_id, user_id });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_delete_group': {
-            const { id } = args;
-            const data = await client.request('POST', `/delete_group/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'sw_undelete_group': {
-            const { id } = args;
-            const data = await client.request('POST', `/undelete_group/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ id }) => {
+        const data = await client.request('POST', `/undelete_group/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }