@talkspresso/mcp-server 1.1.0 → 1.2.0

package/dist/index.js

@@ -26,9 +26,23 @@ else {
     const { registerServiceTools } = await import('./tools/services.js');
     const { registerEarningsTools } = await import('./tools/earnings.js');
     const { registerProfileTools } = await import('./tools/profile.js');
+    const { registerCalendarTools } = await import('./tools/calendar.js');
+    const { registerNotificationTools } = await import('./tools/notifications.js');
+    const { registerTestimonialTools } = await import('./tools/testimonials.js');
+    const { registerRecordingTools } = await import('./tools/recordings.js');
+    const { registerOrganizationTools } = await import('./tools/organization.js');
+    const { registerProductTools } = await import('./tools/products.js');
+    const { registerPromoCodeTools } = await import('./tools/promoCodes.js');
+    const { registerFileLibraryTools } = await import('./tools/fileLibrary.js');
+    const { registerPrequalificationTools } = await import('./tools/prequalification.js');
+    const { registerMessagingTools } = await import('./tools/messaging.js');
+    const { registerLiveTools } = await import('./tools/live.js');
+    const { registerGoogleCalendarTools } = await import('./tools/googleCalendar.js');
+    const { registerBrewTools } = await import('./tools/brew.js');
+    const { registerSubscriptionTools } = await import('./tools/subscription.js');
     const server = new McpServer({
         name: 'talkspresso',
-        version: '1.1.0',
+        version: '1.2.0',
     });
     const apiClient = new TalkspressoClient();
     registerAppointmentTools(server, apiClient);
@@ -36,6 +50,20 @@ else {
     registerServiceTools(server, apiClient);
     registerEarningsTools(server, apiClient);
     registerProfileTools(server, apiClient);
+    registerCalendarTools(server, apiClient);
+    registerNotificationTools(server, apiClient);
+    registerTestimonialTools(server, apiClient);
+    registerRecordingTools(server, apiClient);
+    registerOrganizationTools(server, apiClient);
+    registerProductTools(server, apiClient);
+    registerPromoCodeTools(server, apiClient);
+    registerFileLibraryTools(server, apiClient);
+    registerPrequalificationTools(server, apiClient);
+    registerMessagingTools(server, apiClient);
+    registerLiveTools(server, apiClient);
+    registerGoogleCalendarTools(server, apiClient);
+    registerBrewTools(server, apiClient);
+    registerSubscriptionTools(server, apiClient);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/tools/appointments.js

@@ -92,4 +92,42 @@ export function registerAppointmentTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('check-availability', 'Check available time slots for a specific date and service. Use this before scheduling to see when you are free.', {
+        date: z.string().describe('Date to check in YYYY-MM-DD format'),
+        service_id: z.string().optional().describe('Service ID to check availability for (determines duration). Use list-services to find this.'),
+        duration: z.number().optional().describe('Duration in minutes if no service_id (default 30)'),
+    }, async (params) => {
+        const data = await client.post('/appointments/slots', {
+            date: params.date,
+            service_id: params.service_id,
+            duration: params.duration || 30,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('send-test-invite', 'Send a test appointment invitation to yourself or a specific email. Great for verifying your booking flow works correctly.', {
+        email: z.string().describe('Email address to send the test invite to'),
+        name: z.string().optional().describe('Name for the test client (default "Test Client")'),
+        service_id: z.string().optional().describe('Service ID to use for the test invite. Use list-services to find this.'),
+        scheduled_date: z.string().optional().describe('Date in YYYY-MM-DD format (defaults to tomorrow)'),
+        scheduled_time: z.string().optional().describe('Time in HH:mm format, 24-hour (defaults to 10:00)'),
+    }, async (params) => {
+        // Build a test invite using the standard invite endpoint
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const defaultDate = tomorrow.toISOString().split('T')[0];
+        const data = await client.post('/appointments/invite', {
+            client_name: params.name || 'Test Client',
+            client_email: params.email,
+            service_id: params.service_id,
+            scheduled_date: params.scheduled_date || defaultDate,
+            scheduled_time: params.scheduled_time || '10:00',
+            is_complimentary: true,
+            invitation_message: 'This is a test invitation to verify the booking flow.',
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
 }

package/dist/tools/brew.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerBrewTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/brew.js

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export function registerBrewTools(server, client) {
+    server.tool('get-brew-status', 'Check your Brew AI mentor status including Pro tier, question quota, and active conversation.', {}, async () => {
+        const data = await client.get('/guide/status');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('start-brew-conversation', 'Start a new conversation with Brew or resume your existing one. Brew is your AI business mentor.', {}, async () => {
+        const data = await client.post('/guide/start');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('send-brew-message', 'Send a message to Brew and get AI-powered business advice. Brew can help with pricing, services, profile optimization, and growth strategy.', {
+        conversationId: z.string().describe('The Brew conversation ID (get from start-brew-conversation)'),
+        message: z.string().describe('Your message to Brew'),
+    }, async (params) => {
+        const data = await client.post(`/guide/${params.conversationId}/message`, {
+            message: params.message,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-brew-conversation-history', 'Get the message history for a Brew conversation.', {
+        conversationId: z.string().describe('The Brew conversation ID'),
+    }, async (params) => {
+        const data = await client.get(`/guide/${params.conversationId}/history`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-brew-insights', 'Get proactive coaching insights and nudges from Brew. Shows opportunities, milestones, and reminders based on your activity.', {}, async () => {
+        const data = await client.get('/guide/insights');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('set-brew-goal', 'Set a business goal for Brew to help you work toward.', {
+        goal: z.string().describe('Your business goal (e.g. "Get my first 5 bookings" or "Reach $1000/month")'),
+        conversationId: z.string().optional().describe('Brew conversation ID to associate the goal with'),
+    }, async (params) => {
+        const data = await client.post('/guide/goals', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-brew-preferences', 'Get your Brew notification preferences including intensity, channel, and sleep status.', {}, async () => {
+        const data = await client.get('/guide/preferences');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-brew-preferences', 'Update Brew notification preferences. Control how often and how Brew reaches out.', {
+        intensity: z.enum(['high', 'medium', 'low']).optional().describe('Notification intensity'),
+        channelPreference: z.enum(['email', 'in_app', 'both']).optional().describe('How to receive notifications'),
+        topicFilters: z.array(z.string()).optional().describe('Topics to filter for'),
+    }, async (params) => {
+        const data = await client.put('/guide/preferences', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('sleep-brew', 'Put Brew to sleep for a specified number of weeks. Pauses all proactive notifications.', {
+        weeks: z.number().describe('Number of weeks to sleep (1, 2, or 4)'),
+    }, async (params) => {
+        const data = await client.post('/guide/preferences/sleep', { weeks: params.weeks });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('wake-brew', 'Wake Brew from sleep mode and resume proactive notifications.', {}, async () => {
+        const data = await client.post('/guide/preferences/wake');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-dashboard-insight', 'Get a single focused coaching insight for your dashboard. Returns stage-appropriate advice and next action.', {}, async () => {
+        const data = await client.get('/guide/dashboard-insight');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/calendar.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerCalendarTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/calendar.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export function registerCalendarTools(server, client) {
+    server.tool('get-calendar', 'Get your calendar settings including timezone, availability windows, and booking preferences. Use this to check your current availability schedule.', {}, async () => {
+        const data = await client.get('/calendar/me');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-calendar', 'Update your calendar settings like timezone, availability windows, booking interval, and buffer time. Use this when you want to change your availability schedule or timezone.', {
+        timezone: z.string().optional().describe('IANA timezone string (e.g., "America/New_York", "Europe/London")'),
+        availability: z.record(z.any()).optional().describe('Weekly availability object. Keys are day names (Monday-Sunday), values have is_selected, start_time, end_time.'),
+        booking_interval_days: z.number().optional().describe('How far in advance clients can book (in days)'),
+        buffer_minutes: z.number().optional().describe('Buffer time between appointments in minutes'),
+    }, async (params) => {
+        const data = await client.put('/calendar', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/clients.js

@@ -18,4 +18,20 @@ export function registerClientTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('get-session-history', 'Get rich session history with a specific client including session summaries, action items, and topics discussed. Use this to prep for a meeting or remember what you talked about last time.', {
+        id: z.string().describe('The client ID'),
+    }, async (params) => {
+        const data = await client.get(`/client/${params.id}/session-history`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-client-activity', 'Get client activity dashboard including emails sent, testimonials, pre-qualification responses, and engagement stats.', {
+        id: z.string().describe('The client ID'),
+    }, async (params) => {
+        const data = await client.get(`/client/${params.id}/activity`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
 }

package/dist/tools/earnings.js

@@ -10,4 +10,29 @@ export function registerEarningsTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('get-revenue-summary', 'Get a quick revenue summary: this month earnings, total bookings, new clients, and completed sessions. Use this for a "how is this month going?" check.', {}, async () => {
+        const [appointments, earnings] = await Promise.all([
+            client.get('/appointments/me', { status: 'all', limit: 200 }),
+            client.get('/transaction/my', { limit: 200 }),
+        ]);
+        const now = new Date();
+        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString();
+        const allAppts = appointments.appointments || appointments || [];
+        const allTxns = Array.isArray(earnings) ? earnings : earnings.transactions || [];
+        const thisMonthTxns = allTxns.filter((t) => t.createdAt >= monthStart || t.created_at >= monthStart);
+        const thisMonthRevenue = thisMonthTxns
+            .filter((t) => t.transaction_type === 'payment' || t.type === 'payment')
+            .reduce((sum, t) => sum + (parseFloat(t.amount) || 0), 0);
+        const thisMonthCompleted = allAppts.filter((a) => (a.status === 'completed') && (a.start_time >= monthStart || a.createdAt >= monthStart)).length;
+        const upcomingCount = allAppts.filter((a) => a.status === 'active' || a.status === 'scheduled').length;
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        month: `${now.toLocaleString('default', { month: 'long' })} ${now.getFullYear()}`,
+                        revenue_this_month: `$${thisMonthRevenue.toFixed(2)}`,
+                        completed_sessions_this_month: thisMonthCompleted,
+                        upcoming_sessions: upcomingCount,
+                        total_transactions_this_month: thisMonthTxns.length,
+                    }, null, 2) }],
+        };
+    });
 }

package/dist/tools/fileLibrary.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerFileLibraryTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/fileLibrary.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export function registerFileLibraryTools(server, client) {
+    server.tool('list-files', 'Get all files in your file library. Files can be attached to products, services, or shared with clients.', {}, async () => {
+        const data = await client.get('/file-library');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-file', 'Get detailed information about a specific file in your library.', {
+        id: z.string().describe('The file ID'),
+    }, async (params) => {
+        const data = await client.get(`/file-library/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-file-library-stats', 'Get statistics about your file library including total files, storage used, and file types.', {}, async () => {
+        const data = await client.get('/file-library/stats');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-file-library-folders', 'Get all folders in your file library for organization.', {}, async () => {
+        const data = await client.get('/file-library/folders');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-file', 'Update file metadata like name, description, or folder.', {
+        id: z.string().describe('The file ID to update'),
+        name: z.string().optional().describe('New file name'),
+        description: z.string().optional().describe('File description'),
+        folder: z.string().optional().describe('Folder to move the file into'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/file-library/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-file', 'Delete a file from your library.', {
+        id: z.string().describe('The file ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/file-library/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('add-file-tags', 'Add tags to a file for easier organization and search.', {
+        id: z.string().describe('The file ID'),
+        tags: z.array(z.string()).describe('Tags to add to the file'),
+    }, async (params) => {
+        const data = await client.post(`/file-library/${params.id}/tags`, { tags: params.tags });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/googleCalendar.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerGoogleCalendarTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/googleCalendar.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export function registerGoogleCalendarTools(server, client) {
+    server.tool('get-connected-calendars', 'Get your connected Google Calendar accounts and their calendars. Shows which calendars are selected for conflict checking.', {
+        user_id: z.string().describe('Your user ID'),
+    }, async (params) => {
+        const data = await client.get(`/google-calendar/calendars/${params.user_id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('toggle-calendar-selection', 'Select or deselect a Google Calendar for conflict checking. Selected calendars are checked when clients book.', {
+        user_id: z.string().describe('Your user ID'),
+        calendarId: z.string().describe('The Google Calendar ID to toggle'),
+        isSelected: z.boolean().describe('Whether to select (true) or deselect (false) the calendar'),
+    }, async (params) => {
+        const data = await client.put(`/google-calendar/calendars/${params.user_id}/selected`, {
+            calendarId: params.calendarId,
+            isSelected: params.isSelected,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('check-calendar-conflicts', 'Check if a time range conflicts with your Google Calendar events. Use this before scheduling to avoid double-booking.', {
+        user_id: z.string().describe('Your user ID'),
+        startTime: z.string().describe('Start time in ISO format (e.g. 2026-02-20T10:00:00-06:00)'),
+        endTime: z.string().describe('End time in ISO format (e.g. 2026-02-20T11:00:00-06:00)'),
+    }, async (params) => {
+        const data = await client.post(`/google-calendar/check-conflicts/${params.user_id}`, {
+            startTime: params.startTime,
+            endTime: params.endTime,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/live.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerLiveTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/live.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export function registerLiveTools(server, client) {
+    server.tool('start-live-session', 'Start a new live video session (Go Live). Requires a Pro subscription. Returns a shareable link for viewers to join.', {
+        title: z.string().optional().describe('Title for the live session'),
+    }, async (params) => {
+        const data = await client.post('/live/start', { title: params.title });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-active-live-session', 'Check if you have a currently active live session. Returns session details and share URL if live.', {}, async () => {
+        const data = await client.get('/live/active');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('end-live-session', 'End your active live session.', {
+        slug: z.string().describe('The live session slug (short code)'),
+    }, async (params) => {
+        const data = await client.post(`/live/${params.slug}/end`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-live-session-history', 'Get your past live session history including duration, viewer counts, and status.', {}, async () => {
+        const data = await client.get('/live/history/me');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('send-live-session-invite', 'Send an email invitation to someone to join your active live session.', {
+        slug: z.string().describe('The live session slug'),
+        email: z.string().describe('Email address to send the invite to'),
+        isCohost: z.boolean().optional().describe('Invite as co-host with publishing rights (default false)'),
+    }, async (params) => {
+        const data = await client.post(`/live/${params.slug}/invite`, {
+            email: params.email,
+            isCohost: params.isCohost || false,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/messaging.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerMessagingTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/messaging.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export function registerMessagingTools(server, client) {
+    server.tool('list-conversations', 'Get all your message conversations with clients. Returns conversations sorted by most recent message.', {}, async () => {
+        const data = await client.get('/messaging/conversations', { userType: 'provider' });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-conversation-messages', 'Get messages from a specific conversation. Returns the most recent messages in chronological order.', {
+        conversation_id: z.string().describe('The conversation ID'),
+        limit: z.number().optional().describe('Number of messages to return (default 50)'),
+    }, async (params) => {
+        const queryParams = {};
+        if (params.limit)
+            queryParams.limit = String(params.limit);
+        const data = await client.get(`/messaging/conversations/${params.conversation_id}/messages`, queryParams);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('send-message', 'Send a message to a client in an existing conversation. Use list-conversations first to find the conversation ID.', {
+        conversation_id: z.string().describe('The conversation ID'),
+        message: z.string().describe('The message text to send'),
+        sender_name: z.string().describe('Your name (the provider name)'),
+    }, async (params) => {
+        const data = await client.post(`/messaging/conversations/${params.conversation_id}/messages`, {
+            senderId: 'provider',
+            senderType: 'provider',
+            senderName: params.sender_name,
+            message: params.message,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-unread-message-count', 'Get the total number of unread messages across all conversations.', {}, async () => {
+        const data = await client.get('/messaging/unread-count', { userType: 'provider' });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('mark-conversation-read', 'Mark all messages in a conversation as read.', {
+        conversation_id: z.string().describe('The conversation ID to mark as read'),
+    }, async (params) => {
+        const data = await client.post(`/messaging/conversations/${params.conversation_id}/read`, {
+            userType: 'provider',
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/notifications.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerNotificationTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/notifications.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export function registerNotificationTools(server, client) {
+    server.tool('list-notifications', 'Get all your notifications including new bookings, messages, and system alerts. Use this to check what needs your attention.', {
+        user_id: z.string().describe('Your user ID (get this from get-profile first)'),
+    }, async (params) => {
+        const data = await client.get(`/notification/${params.user_id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('mark-notification-read', 'Mark a single notification as read.', {
+        notification_id: z.string().describe('The notification ID to mark as read'),
+    }, async (params) => {
+        const data = await client.put(`/notification/${params.notification_id}/read`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('mark-all-notifications-read', 'Mark all your notifications as read. Use this to clear your notification count.', {}, async () => {
+        const data = await client.put('/notification/read-all');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/organization.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerOrganizationTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/organization.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export function registerOrganizationTools(server, client) {
+    server.tool('list-my-organizations', 'Get organizations you are an admin or member of. Use this to see your org memberships.', {}, async () => {
+        const data = await client.get('/organization/my');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-organization', 'Get detailed information about a specific organization by ID.', {
+        id: z.string().describe('The organization ID'),
+    }, async (params) => {
+        const data = await client.get(`/organization/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-organization-members', 'Get all members of an organization. Use this to see who belongs to the org.', {
+        id: z.string().describe('The organization ID'),
+    }, async (params) => {
+        const data = await client.get(`/organization/${params.id}/members`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-organization-stats', 'Get statistics for an organization including member count, booking count, and revenue.', {
+        id: z.string().describe('The organization ID'),
+    }, async (params) => {
+        const data = await client.get(`/organization/${params.id}/stats`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-organization', 'Update organization settings like name, description, or branding.', {
+        id: z.string().describe('The organization ID to update'),
+        name: z.string().optional().describe('Organization name'),
+        description: z.string().optional().describe('Organization description'),
+        slug: z.string().optional().describe('URL slug for the organization page'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/organization/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('add-organization-member', 'Add a new member to an organization.', {
+        id: z.string().describe('The organization ID'),
+        email: z.string().describe('Email of the person to add'),
+        name: z.string().optional().describe('Name of the person'),
+        role: z.string().optional().describe('Role within the organization'),
+    }, async (params) => {
+        const { id, ...body } = params;
+        const data = await client.post(`/organization/${id}/members`, body);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('send-organization-invitation', 'Send an invitation email to join an organization.', {
+        id: z.string().describe('The organization ID'),
+        email: z.string().describe('Email to send the invitation to'),
+        role: z.string().optional().describe('Role for the invited person'),
+    }, async (params) => {
+        const { id, ...body } = params;
+        const data = await client.post(`/organization/${id}/invitations`, body);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/prequalification.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerPrequalificationTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/prequalification.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export function registerPrequalificationTools(server, client) {
+    server.tool('list-intake-questions', 'Get all your intake (prequalification) questions. These are shown to clients before booking or messaging you.', {}, async () => {
+        const data = await client.get('/prequalification/questions');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-intake-question', 'Create a new intake question for clients to answer before booking or messaging.', {
+        question: z.string().describe('The question text'),
+        questionType: z.enum(['text', 'textarea', 'select', 'multiselect', 'radio', 'checkbox']).optional().describe('Question type (default text)'),
+        options: z.array(z.string()).optional().describe('Answer options for select/multiselect/radio types'),
+        isRequired: z.boolean().optional().describe('Whether the question is required (default true)'),
+        placeholder: z.string().optional().describe('Placeholder text for the input'),
+        helperText: z.string().optional().describe('Helper text shown below the question'),
+        context: z.enum(['booking', 'messaging', 'both']).optional().describe('When to show: booking, messaging, or both (default both)'),
+    }, async (params) => {
+        const data = await client.post('/prequalification/questions', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-intake-question', 'Update an existing intake question.', {
+        id: z.string().describe('The question ID to update'),
+        question: z.string().optional().describe('Updated question text'),
+        questionType: z.enum(['text', 'textarea', 'select', 'multiselect', 'radio', 'checkbox']).optional().describe('Updated question type'),
+        options: z.array(z.string()).optional().describe('Updated answer options'),
+        isRequired: z.boolean().optional().describe('Whether the question is required'),
+        isActive: z.boolean().optional().describe('Enable or disable the question'),
+        placeholder: z.string().optional().describe('Updated placeholder text'),
+        helperText: z.string().optional().describe('Updated helper text'),
+        context: z.enum(['booking', 'messaging', 'both']).optional().describe('When to show the question'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/prequalification/questions/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-intake-question', 'Delete an intake question.', {
+        id: z.string().describe('The question ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/prequalification/questions/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('reorder-intake-questions', 'Reorder your intake questions by providing the question IDs in the desired order.', {
+        questionIds: z.array(z.string()).describe('Array of question IDs in the desired order'),
+    }, async (params) => {
+        const data = await client.put('/prequalification/questions/reorder', { questionIds: params.questionIds });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('generate-intake-question-suggestions', 'Use AI to generate intake question suggestions based on your profile. Great for setting up intake forms quickly.', {}, async () => {
+        const data = await client.post('/prequalification/questions/ai-suggestions');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('generate-service-intake-questions', 'Use AI to generate intake questions tailored to a specific service or course.', {
+        serviceTitle: z.string().describe('The title of the service'),
+        serviceDescription: z.string().optional().describe('Description of the service'),
+        sessionCount: z.number().optional().describe('Number of sessions in the package'),
+    }, async (params) => {
+        const data = await client.post('/prequalification/questions/generate-for-service', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-client-intake-responses', 'Get a specific client\'s intake question responses. Use this to review what a client shared before their session.', {
+        client_id: z.string().describe('The client ID'),
+        serviceId: z.string().optional().describe('Filter by service ID'),
+        appointmentId: z.string().optional().describe('Filter by appointment ID'),
+    }, async (params) => {
+        const queryParams = {};
+        if (params.serviceId)
+            queryParams.serviceId = params.serviceId;
+        if (params.appointmentId)
+            queryParams.appointmentId = params.appointmentId;
+        const data = await client.get(`/prequalification/responses/client/${params.client_id}`, queryParams);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('seed-default-intake-questions', 'Auto-generate and save default intake questions based on your profile. Useful for first-time setup.', {
+        force: z.boolean().optional().describe('Force re-seed even if questions already exist (default false)'),
+    }, async (params) => {
+        const data = await client.post('/prequalification/questions/seed-defaults', { force: params.force || false });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/products.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerProductTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/products.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export function registerProductTools(server, client) {
+    server.tool('list-products', 'Get all your digital products (downloads, video courses, bundles). Use this to see what you have for sale.', {}, async () => {
+        const data = await client.get('/product/me');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-product', 'Get detailed information about a specific product including files, pricing, and sales stats.', {
+        id: z.string().describe('The product ID'),
+    }, async (params) => {
+        const data = await client.get(`/product/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-product', 'Create a new digital product to sell on your profile. Supports downloads (PDFs, files), videos, and bundles.', {
+        title: z.string().describe('Product title'),
+        short_description: z.string().describe('Short description (shown in product card)'),
+        long_description: z.string().optional().describe('Full description with details'),
+        price: z.number().describe('Price in dollars (0 for free)'),
+        product_type: z.enum(['download', 'video', 'bundle']).describe('Type of product'),
+        status: z.enum(['draft', 'active']).optional().describe('Product status (default draft)'),
+        keywords: z.array(z.string()).optional().describe('Keywords for SEO and discovery'),
+    }, async (params) => {
+        const data = await client.post('/product', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-product', 'Update an existing product (title, price, description, status, etc.).', {
+        id: z.string().describe('The product ID to update'),
+        title: z.string().optional().describe('New title'),
+        short_description: z.string().optional().describe('New short description'),
+        long_description: z.string().optional().describe('New full description'),
+        price: z.number().optional().describe('New price in dollars'),
+        status: z.enum(['draft', 'active', 'archived']).optional().describe('Product status'),
+        keywords: z.array(z.string()).optional().describe('Updated keywords'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/product/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-product', 'Delete a product. This removes it from your store.', {
+        id: z.string().describe('The product ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/product/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-product-analytics', 'Get analytics for your products including views, sales, and revenue. Use this to check how your products are performing.', {}, async () => {
+        const data = await client.get('/product/analytics');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('list-product-purchases', 'Get all purchases across all your products. See who bought what and when.', {}, async () => {
+        const data = await client.get('/product/purchases');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-product-purchases', 'Get purchases for a specific product. See who bought it.', {
+        product_id: z.string().describe('The product ID to get purchases for'),
+    }, async (params) => {
+        const data = await client.get(`/product/${params.product_id}/purchases`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('generate-product-details', 'Use AI to generate product title, description, keywords, and suggested price from a brief description. Great for quickly creating product listings.', {
+        description: z.string().describe('Brief description of what the product is about (at least 10 characters)'),
+        product_type: z.enum(['download', 'video', 'bundle']).optional().describe('Type of product (default download)'),
+    }, async (params) => {
+        const data = await client.post('/product/generate-details', {
+            description: params.description,
+            productType: params.product_type || 'download',
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/profile.js

@@ -23,4 +23,30 @@ export function registerProfileTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('get-booking-link', 'Get a shareable booking link for a specific service or your general booking page. Use this when you want to send someone a link to book with you.', {
+        service_id: z.string().optional().describe('Service ID for a specific service link. If omitted, returns your general booking page.'),
+    }, async (params) => {
+        const profile = await client.get('/profile/me');
+        const handle = profile.handle || profile.website;
+        const baseUrl = 'https://app.talkspresso.com';
+        if (params.service_id) {
+            const services = await client.get('/service/me');
+            const service = (Array.isArray(services) ? services : services.services || [])
+                .find((s) => s.id === params.service_id);
+            const slug = service?.slug || params.service_id;
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            booking_link: `${baseUrl}/${handle}/${slug}`,
+                            general_link: `${baseUrl}/${handle}`,
+                            service_title: service?.title || 'Unknown service',
+                        }, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        booking_link: `${baseUrl}/${handle}`,
+                        handle,
+                    }, null, 2) }],
+        };
+    });
 }

package/dist/tools/promoCodes.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerPromoCodeTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/promoCodes.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export function registerPromoCodeTools(server, client) {
+    server.tool('list-promo-codes', 'Get all your promo codes including their status, usage count, and discount details. Use this to manage discounts and promotions.', {}, async () => {
+        const data = await client.get('/promo-code');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-promo-code', 'Get detailed information about a specific promo code including usage history.', {
+        id: z.string().describe('The promo code ID'),
+    }, async (params) => {
+        const data = await client.get(`/promo-code/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-promo-code', 'Create a new promo code for discounts on services or products. Use this to offer promotions to clients.', {
+        code: z.string().describe('The promo code string clients will enter (e.g., "WELCOME20")'),
+        discount_type: z.enum(['percentage', 'fixed']).describe('Type of discount: percentage off or fixed dollar amount'),
+        discount_value: z.number().describe('Discount amount (e.g., 20 for 20% or $20)'),
+        max_uses: z.number().optional().describe('Maximum number of times this code can be used (unlimited if omitted)'),
+        expires_at: z.string().optional().describe('Expiration date in ISO format (no expiry if omitted)'),
+        service_ids: z.array(z.string()).optional().describe('Limit to specific service IDs (all services if omitted)'),
+        is_active: z.boolean().optional().describe('Whether the code is active (default true)'),
+    }, async (params) => {
+        const data = await client.post('/promo-code', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-promo-code', 'Update an existing promo code settings.', {
+        id: z.string().describe('The promo code ID to update'),
+        code: z.string().optional().describe('Updated code string'),
+        discount_type: z.enum(['percentage', 'fixed']).optional().describe('Updated discount type'),
+        discount_value: z.number().optional().describe('Updated discount amount'),
+        max_uses: z.number().optional().describe('Updated max uses'),
+        expires_at: z.string().optional().describe('Updated expiration date'),
+        is_active: z.boolean().optional().describe('Enable or disable the code'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/promo-code/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-promo-code', 'Permanently delete a promo code.', {
+        id: z.string().describe('The promo code ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/promo-code/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('toggle-promo-code-active', 'Toggle a promo code between active and inactive without deleting it.', {
+        id: z.string().describe('The promo code ID to toggle'),
+    }, async (params) => {
+        const data = await client.post(`/promo-code/${params.id}/toggle-active`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-promo-code-analytics', 'Get analytics for all your promo codes including total usage, revenue impact, and top-performing codes.', {}, async () => {
+        const data = await client.get('/promo-code/analytics');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/recordings.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerRecordingTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/recordings.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export function registerRecordingTools(server, client) {
+    server.tool('list-recordings', 'Get all your session recordings. Returns the recording library with titles, durations, transcription status, and more. Use this to browse past session recordings.', {
+        page: z.number().optional().describe('Page number (default 1)'),
+        limit: z.number().optional().describe('Results per page (default 20)'),
+        visibility: z.enum(['all', 'private', 'unlisted', 'public']).optional().describe('Filter by visibility (default all)'),
+    }, async (params) => {
+        const data = await client.get('/recordings', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-recording', 'Get detailed information about a specific recording including transcription, summary, key takeaways, and action items. Use this to review what happened in a past session.', {
+        id: z.string().describe('The recording ID'),
+    }, async (params) => {
+        const data = await client.get(`/recordings/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-recording', 'Update a recording title, description, or visibility setting.', {
+        id: z.string().describe('The recording ID to update'),
+        title: z.string().optional().describe('New title for the recording'),
+        description: z.string().optional().describe('New description'),
+        visibility: z.enum(['private', 'unlisted', 'public']).optional().describe('Visibility: private (only you), unlisted (link only), public (anyone)'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/recordings/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-recording', 'Permanently delete a recording. This cannot be undone.', {
+        id: z.string().describe('The recording ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/recordings/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-client-recordings', 'Get all recordings from sessions with a specific client. Use this to review session history with a particular client.', {
+        client_id: z.string().describe('The client ID to get recordings for'),
+    }, async (params) => {
+        const data = await client.get(`/recordings/client/${params.client_id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-recording-files', 'Get individual participant recording files for a session (for editing workflows like Descript). Returns signed download URLs.', {
+        id: z.string().describe('The recording ID'),
+    }, async (params) => {
+        const data = await client.get(`/recordings/${params.id}/files`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-product-from-recording', 'Turn a session recording into a sellable digital product. Automatically generates title, description, and keywords from the recording summary.', {
+        id: z.string().describe('The recording ID to create a product from'),
+        title: z.string().optional().describe('Product title (auto-generated from recording if omitted)'),
+        description: z.string().optional().describe('Product description (auto-generated from summary if omitted)'),
+        price: z.number().describe('Price in dollars (e.g., 29 for $29)'),
+        status: z.enum(['draft', 'active']).optional().describe('Product status (default draft)'),
+    }, async (params) => {
+        const { id, ...body } = params;
+        const data = await client.post(`/recordings/${id}/create-product`, body);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('retry-recording-transcription', 'Retry transcription and AI summary for recordings that failed or are stuck. Use this if a recording shows "failed" or "pending" transcription status.', {}, async () => {
+        const data = await client.post('/recordings/admin/retry-transcriptions');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/services.js

@@ -18,6 +18,14 @@ export function registerServiceTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('get-service', 'Get detailed information about a specific service including pricing, duration, and logistics.', {
+        id: z.string().describe('The service ID'),
+    }, async (params) => {
+        const data = await client.get(`/service/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
     server.tool('update-service', 'Update an existing service', {
         id: z.string().describe('Service ID to update'),
         title: z.string().optional().describe('New title'),
@@ -32,4 +40,28 @@ export function registerServiceTools(server, client) {
             content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
         };
     });
+    server.tool('delete-service', 'Delete a service from your profile. This cannot be undone.', {
+        id: z.string().describe('The service ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/service/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('duplicate-service', 'Create a copy of an existing service. Useful for creating variations of popular services.', {
+        id: z.string().describe('The service ID to duplicate'),
+    }, async (params) => {
+        const data = await client.post(`/service/${params.id}/duplicate`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-service-bookings', 'Get all bookings for a specific service. See who has booked and upcoming sessions.', {
+        id: z.string().describe('The service ID'),
+    }, async (params) => {
+        const data = await client.get(`/service/${params.id}/bookings`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
 }

package/dist/tools/subscription.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerSubscriptionTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/subscription.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export function registerSubscriptionTools(server, client) {
+    server.tool('get-my-subscription', 'Get your current subscription plan details including plan name, status, billing period, and features.', {}, async () => {
+        const data = await client.get('/subscription/me');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-payment-methods', 'Get your saved payment methods on file.', {}, async () => {
+        const data = await client.get('/subscription/payment-methods');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('get-stripe-account-link', 'Get a Stripe Connect onboarding or account link. Use this to set up or manage your payment receiving account.', {}, async () => {
+        const data = await client.get('/subscription/create-account-link');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-billing-portal-session', 'Open the Stripe billing portal to manage your subscription, update payment method, or view invoices.', {
+        return_url: z.string().optional().describe('URL to redirect back to after the portal session'),
+    }, async (params) => {
+        const data = await client.post('/subscription/billing-portal', {
+            return_url: params.return_url,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/tools/testimonials.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TalkspressoClient } from '../client.js';
+export declare function registerTestimonialTools(server: McpServer, client: TalkspressoClient): void;

package/dist/tools/testimonials.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export function registerTestimonialTools(server, client) {
+    server.tool('list-testimonials', 'Get all your testimonials from clients. Use this when someone asks about reviews, social proof, or client feedback.', {}, async () => {
+        const data = await client.get('/testimonial');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('create-testimonial', 'Manually add a testimonial from a client. Use this when you have offline feedback you want to add to your profile.', {
+        author_name: z.string().describe('Name of the person giving the testimonial'),
+        author_title: z.string().optional().describe('Title or role of the person (e.g., "CEO at Acme")'),
+        content: z.string().describe('The testimonial text'),
+        rating: z.number().optional().describe('Rating from 1-5 (default 5)'),
+    }, async (params) => {
+        const data = await client.post('/testimonial', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('request-testimonial', 'Send a testimonial request email to a client. They will receive a link to submit their testimonial. Use this after completing a successful session.', {
+        client_id: z.string().describe('The client ID to request a testimonial from. Use list-clients to find this.'),
+        appointment_id: z.string().optional().describe('Optional appointment ID to reference a specific session'),
+    }, async (params) => {
+        const data = await client.post('/testimonial/request', params);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('approve-testimonial', 'Approve a pending testimonial submitted by a client so it appears on your profile.', {
+        id: z.string().describe('The testimonial ID to approve'),
+    }, async (params) => {
+        const data = await client.post(`/testimonial/${params.id}/approve`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('reject-testimonial', 'Reject a pending testimonial so it does not appear on your profile.', {
+        id: z.string().describe('The testimonial ID to reject'),
+    }, async (params) => {
+        const data = await client.post(`/testimonial/${params.id}/reject`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('toggle-featured-testimonial', 'Toggle whether a testimonial is featured (highlighted) on your profile.', {
+        id: z.string().describe('The testimonial ID to toggle featured status'),
+    }, async (params) => {
+        const data = await client.post(`/testimonial/${params.id}/toggle-featured`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('update-testimonial', 'Update an existing testimonial (edit text, visibility, etc.).', {
+        id: z.string().describe('The testimonial ID to update'),
+        content: z.string().optional().describe('Updated testimonial text'),
+        is_visible: z.boolean().optional().describe('Whether the testimonial is visible on your profile'),
+    }, async (params) => {
+        const { id, ...updateData } = params;
+        const data = await client.put(`/testimonial/${id}`, updateData);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+    server.tool('delete-testimonial', 'Permanently delete a testimonial.', {
+        id: z.string().describe('The testimonial ID to delete'),
+    }, async (params) => {
+        const data = await client.delete(`/testimonial/${params.id}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talkspresso/mcp-server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Manage your Talkspresso business through Claude, ChatGPT, or any MCP-compatible AI",
   "bin": {
     "talkspresso-mcp": "./dist/index.js"