@divyacon/piece-mailchimp 0.0.0-stage → 0.1.0

package/src/lib/actions/find-customer.ts

@@ -0,0 +1,88 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { mailchimpCommon } from '../common';
+import { mailchimpAuth } from '../..';
+import mailchimp from '@mailchimp/mailchimp_marketing';
+import { MailchimpClient } from '../common/types';
+
+export const findCustomer = createAction({
+  auth: mailchimpAuth,
+  name: 'find_customer',
+  displayName: 'Find Customer',
+  description: 'Find a customer by email address in a store',
+  audience: 'both',
+  aiMetadata: { description: 'Looks up e-commerce customers in a specified connected store by email address, with optional pagination and field filtering. Use to retrieve a store customer record before referencing or syncing it. Requires a store and email; read-only and idempotent.', idempotent: true },
+  props: {
+    store_id: mailchimpCommon.mailChimpStoreIdDropdown,
+    email_address: Property.ShortText({
+      displayName: 'Email Address',
+      description: 'Email address to search for',
+      required: true,
+    }),
+    fields: Property.LongText({
+      displayName: 'Include Fields',
+      description: 'Comma-separated list of fields to return',
+      required: false,
+    }),
+    exclude_fields: Property.LongText({
+      displayName: 'Exclude Fields',
+      description: 'Comma-separated list of fields to exclude',
+      required: false,
+    }),
+    count: Property.Number({
+      displayName: 'Count',
+      description: 'Number of records to return (max 1000)',
+      required: false,
+      defaultValue: 10,
+    }),
+    offset: Property.Number({
+      displayName: 'Offset',
+      description: 'Number of records to skip for pagination',
+      required: false,
+      defaultValue: 0,
+    }),
+  },
+  async run(context) {
+    const accessToken = getAccessTokenOrThrow(context.auth);
+    const server = await mailchimpCommon.getMailChimpServerPrefix(accessToken);
+    
+    const client = mailchimp as unknown as MailchimpClient;
+    client.setConfig({
+      accessToken: accessToken,
+      server: server,
+    });
+
+    try {
+      const options: any = {
+        email_address: context.propsValue.email_address,
+        count: context.propsValue.count || 10,
+        offset: context.propsValue.offset || 0,
+      };
+      
+      if (context.propsValue.fields) {
+        options.fields = context.propsValue.fields.split(',').map(f => f.trim());
+      }
+      
+      if (context.propsValue.exclude_fields) {
+        options.exclude_fields = context.propsValue.exclude_fields.split(',').map(f => f.trim());
+      }
+
+      const result = await client.ecommerce.getAllStoreCustomers(
+        context.propsValue.store_id!,
+        options
+      );
+
+      return {
+        success: true,
+        store_id: result.store_id,
+        customers: result.customers,
+        total_items: result.total_items,
+        search_email: context.propsValue.email_address,
+        found_customers: result.customers.length,
+        _links: result._links,
+      };
+    } catch (error: any) {
+      throw new Error(`Failed to find customer: ${error.message || JSON.stringify(error)}`);
+    }
+  },
+});

package/src/lib/actions/find-subscriber.ts

@@ -0,0 +1,307 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { mailchimpAuth } from '../..';
+import { mailchimpCommon } from '../common';
+import mailchimp from '@mailchimp/mailchimp_marketing';
+
+export const findSubscriber = createAction({
+  auth: mailchimpAuth,
+  name: 'find_subscriber',
+  displayName: 'Find Subscriber',
+  description: 'Search for subscribers across all lists or within a specific list. This action provides comprehensive subscriber information including merge fields, interests, and activity data.',
+  audience: 'both',
+  aiMetadata: { description: 'Looks up a subscriber by exact email, returning merge fields, interests, and activity data: when an audience (list) is specified it checks that one list, and when left empty it searches every list in the account. Use to find a contact and inspect their profile or status. Requires the email; read-only and idempotent.', idempotent: true },
+  props: {
+    list_id: mailchimpCommon.mailChimpListIdDropdown,
+    email: Property.ShortText({
+      displayName: 'Email Address',
+      description: 'Email address of the subscriber to search for',
+      required: true,
+    }),
+    include_fields: Property.Array({
+      displayName: 'Include Fields',
+      description: 'Fields to include in the response (leave empty for all fields). Use dot notation for nested fields (e.g., "merge_fields.FNAME")',
+      required: false,
+    }),
+    exclude_fields: Property.Array({
+      displayName: 'Exclude Fields',
+      description: 'Fields to exclude from the response. Use dot notation for nested fields',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const access_token = context.auth.access_token;
+    const mailChimpServerPrefix = await mailchimpCommon.getMailChimpServerPrefix(access_token);
+    
+    mailchimp.setConfig({
+      accessToken: access_token,
+      server: mailChimpServerPrefix,
+    });
+
+    try {
+      const searchEmail = context.propsValue.email!;
+      const listId = context.propsValue.list_id;
+      
+      const options: any = {};
+      
+      if (context.propsValue.include_fields && context.propsValue.include_fields.length > 0) {
+        options.fields = context.propsValue.include_fields.join(',');
+      }
+      
+      if (context.propsValue.exclude_fields && context.propsValue.exclude_fields.length > 0) {
+        options.exclude_fields = context.propsValue.exclude_fields.join(',');
+      }
+
+      if (listId) {
+        try {
+          const subscriberHash = mailchimpCommon.getMD5EmailHash(searchEmail);
+          const subscriber = await (mailchimp as any).lists.getListMember(listId, subscriberHash, options);
+          
+          return {
+            success: true,
+            found: true,
+            match_type: 'exact',
+            search_query: searchEmail,
+            search_scope: `List: ${listId}`,
+            total_matches: 1,
+            subscribers: [{
+              id: subscriber.id,
+              email_address: subscriber.email_address,
+              unique_email_id: subscriber.unique_email_id,
+              email_type: subscriber.email_type,
+              status: subscriber.status,
+              merge_fields: subscriber.merge_fields,
+              interests: subscriber.interests,
+              stats: subscriber.stats,
+              ip_signup: subscriber.ip_signup,
+              timestamp_signup: subscriber.timestamp_signup,
+              ip_opt: subscriber.ip_opt,
+              timestamp_opt: subscriber.timestamp_opt,
+              member_rating: subscriber.member_rating,
+              last_changed: subscriber.last_changed,
+              language: subscriber.language,
+              vip: subscriber.vip,
+              email_client: subscriber.email_client,
+              location: subscriber.location,
+              tags_count: subscriber.tags_count,
+              list_id: subscriber.list_id,
+            }],
+            primary_subscriber: {
+              id: subscriber.id,
+              email_address: subscriber.email_address,
+              status: subscriber.status,
+              list_id: subscriber.list_id,
+              full_name: subscriber.merge_fields?.FNAME && subscriber.merge_fields?.LNAME ? 
+                `${subscriber.merge_fields.FNAME} ${subscriber.merge_fields.LNAME}` : 
+                subscriber.merge_fields?.FNAME || subscriber.merge_fields?.LNAME || 'N/A',
+              company: subscriber.merge_fields?.COMPANY || 'N/A',
+              phone: subscriber.merge_fields?.PHONE || 'N/A',
+              member_since: subscriber.timestamp_signup ? 
+                new Date(subscriber.timestamp_signup).toLocaleDateString() : 'N/A',
+              last_activity: subscriber.last_changed ? 
+                new Date(subscriber.last_changed).toLocaleDateString() : 'N/A',
+              member_rating: subscriber.member_rating || 0,
+              vip_status: subscriber.vip ? 'VIP' : 'Standard',
+              email_type: subscriber.email_type || 'html',
+              language: subscriber.language || 'en',
+            },
+            search_summary: {
+              query: searchEmail,
+              scope: `Limited to list: ${listId}`,
+              exact_matches: 1,
+              partial_matches: 0,
+              total_results: 1,
+            },
+          };
+        } catch (listError: any) {
+          if (listError.status === 404) {
+            return {
+              success: true,
+              found: false,
+              match_type: 'none',
+              search_query: searchEmail,
+              search_scope: `List: ${listId}`,
+              message: `Subscriber with email "${searchEmail}" not found in the specified list`,
+              search_summary: {
+                query: searchEmail,
+                scope: `Limited to list: ${listId}`,
+                exact_matches: 0,
+                partial_matches: 0,
+                total_results: 0,
+                suggestions: [
+                  'Verify the email address is spelled correctly',
+                  'Check if the subscriber exists in a different list',
+                  'Ensure the subscriber has not been unsubscribed or deleted',
+                  'Try searching without specifying a list ID to search across all lists',
+                ],
+              },
+            };
+          }
+          throw listError;
+        }
+      } else {
+        const allLists = await (mailchimp as any).lists.getAllLists({
+          fields: ['lists.id', 'lists.name'],
+          count: 1000,
+        });
+
+        const foundSubscribers: any[] = [];
+        const searchPromises = allLists.lists.map(async (list: any) => {
+          try {
+            const subscriberHash = mailchimpCommon.getMD5EmailHash(searchEmail);
+            const subscriber = await (mailchimp as any).lists.getListMember(list.id, subscriberHash, options);
+            
+            return {
+              id: subscriber.id,
+              email_address: subscriber.email_address,
+              unique_email_id: subscriber.unique_email_id,
+              email_type: subscriber.email_type,
+              status: subscriber.status,
+              merge_fields: subscriber.merge_fields,
+              interests: subscriber.interests,
+              stats: subscriber.stats,
+              ip_signup: subscriber.ip_signup,
+              timestamp_signup: subscriber.timestamp_signup,
+              ip_opt: subscriber.ip_opt,
+              timestamp_opt: subscriber.timestamp_opt,
+              member_rating: subscriber.member_rating,
+              last_changed: subscriber.last_changed,
+              language: subscriber.language,
+              vip: subscriber.vip,
+              email_client: subscriber.email_client,
+              location: subscriber.location,
+              tags_count: subscriber.tags_count,
+              list_id: subscriber.list_id,
+              list_name: list.name,
+            };
+          } catch (error: any) {
+            if (error.status === 404) {
+              return null;
+            }
+            return {
+              list_id: list.id,
+              list_name: list.name,
+              error: `Failed to check list: ${error.message}`,
+            };
+          }
+        });
+
+        const results = await Promise.all(searchPromises);
+        const validSubscribers = results.filter(result => result && !result.error);
+        const errors = results.filter(result => result && result.error);
+
+        if (validSubscribers.length > 0) {
+          return {
+            success: true,
+            found: true,
+            match_type: 'exact',
+            search_query: searchEmail,
+            search_scope: 'All Lists',
+            total_matches: validSubscribers.length,
+            subscribers: validSubscribers,
+            primary_subscriber: {
+              id: validSubscribers[0].id,
+              email_address: validSubscribers[0].email_address,
+              status: validSubscribers[0].status,
+              list_id: validSubscribers[0].list_id,
+              list_name: validSubscribers[0].list_name,
+              full_name: validSubscribers[0].merge_fields?.FNAME && validSubscribers[0].merge_fields?.LNAME ? 
+                `${validSubscribers[0].merge_fields.FNAME} ${validSubscribers[0].merge_fields.LNAME}` : 
+                validSubscribers[0].merge_fields?.FNAME || validSubscribers[0].merge_fields?.LNAME || 'N/A',
+              company: validSubscribers[0].merge_fields?.COMPANY || 'N/A',
+              phone: validSubscribers[0].merge_fields?.PHONE || 'N/A',
+              member_since: validSubscribers[0].timestamp_signup ? 
+                new Date(validSubscribers[0].timestamp_signup).toLocaleDateString() : 'N/A',
+              last_activity: validSubscribers[0].last_changed ? 
+                new Date(validSubscribers[0].last_changed).toLocaleDateString() : 'N/A',
+              member_rating: validSubscribers[0].member_rating || 0,
+              vip_status: validSubscribers[0].vip ? 'VIP' : 'Standard',
+              email_type: validSubscribers[0].email_type || 'html',
+              language: validSubscribers[0].language || 'en',
+            },
+            search_summary: {
+              query: searchEmail,
+              scope: 'Searched across all lists',
+              exact_matches: validSubscribers.length,
+              partial_matches: 0,
+              total_results: validSubscribers.length,
+              lists_searched: allLists.lists.length,
+              search_errors: errors.length > 0 ? errors : undefined,
+            },
+          };
+        } else {
+          return {
+            success: true,
+            found: false,
+            match_type: 'none',
+            search_query: searchEmail,
+            search_scope: 'All Lists',
+            message: `No subscribers found matching the email: ${searchEmail}`,
+            search_summary: {
+              query: searchEmail,
+              scope: 'Searched across all lists',
+              exact_matches: 0,
+              partial_matches: 0,
+              total_results: 0,
+              lists_searched: allLists.lists.length,
+              search_errors: errors.length > 0 ? errors : undefined,
+              suggestions: [
+                'Verify the email address is spelled correctly',
+                'Check if the subscriber exists in a different list',
+                'Ensure the subscriber has not been unsubscribed or deleted',
+                'Consider checking if the email was entered with different capitalization',
+                'Verify the subscriber is not in an archived or deleted list',
+              ],
+            },
+          };
+        }
+      }
+    } catch (error: any) {
+      if (error.status === 400) {
+        return {
+          success: false,
+          error: 'Invalid search request',
+          message: 'The search request was invalid. This could be due to malformed search parameters or invalid list ID.',
+          detail: error.detail || 'Bad request',
+          suggestions: [
+            'Verify the email address format is correct',
+            'Check that the list ID (if provided) is valid',
+            'Ensure all required parameters are provided',
+            'Validate the field names in include/exclude fields',
+          ],
+        };
+      }
+      
+      if (error.status === 403) {
+        return {
+          success: false,
+          error: 'Access denied',
+          message: 'You do not have permission to search for subscribers. Check your API key permissions.',
+          detail: error.detail || 'Forbidden',
+          suggestions: [
+            'Verify your API key has the necessary permissions',
+            'Check that you have access to the specified list (if provided)',
+            'Ensure your account is active and in good standing',
+            'Confirm you have subscriber read permissions enabled',
+          ],
+        };
+      }
+      
+      if (error.status === 404 && context.propsValue.list_id) {
+        return {
+          success: false,
+          error: 'List not found',
+          message: `The list with ID "${context.propsValue.list_id}" could not be found.`,
+          detail: error.detail || 'The requested resource could not be found',
+          suggestions: [
+            'Verify the list ID is correct and exists in your Mailchimp account',
+            'Check that you have access to the specified list',
+            'Ensure the list has not been deleted or archived',
+            'Try searching without specifying a list ID to search across all lists',
+          ],
+        };
+      }
+      
+      throw new Error(`Failed to search for subscriber: ${error.message || JSON.stringify(error)}`);
+    }
+  },
+});

package/src/lib/actions/find-tag.ts

@@ -0,0 +1,57 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { mailchimpCommon } from '../common';
+import { mailchimpAuth } from '../..';
+import mailchimp from '@mailchimp/mailchimp_marketing';
+import { MailchimpClient } from '../common/types';
+
+export const findTag = createAction({
+  auth: mailchimpAuth,
+  name: 'find_tag',
+  displayName: 'Find Tag',
+  description: 'Search for tags on a list by name',
+  audience: 'both',
+  aiMetadata: { description: 'Searches the tags defined on an audience (list): an empty tag-name fetches all tags, while a provided name filters to matching tags. Use to discover available tags or confirm a tag exists before tagging contacts. Requires the target list; read-only and idempotent.', idempotent: true },
+  props: {
+    list_id: mailchimpCommon.mailChimpListIdDropdown,
+    name: Property.ShortText({
+      displayName: 'Tag Name',
+      description: 'Search query to filter tags (optional - if empty, returns all tags)',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const accessToken = getAccessTokenOrThrow(context.auth);
+    const server = await mailchimpCommon.getMailChimpServerPrefix(accessToken);
+    
+    const client = mailchimp as unknown as MailchimpClient;
+    client.setConfig({
+      accessToken: accessToken,
+      server: server,
+    });
+
+    try {
+      const options: any = {};
+      
+      if (context.propsValue.name) {
+        options.name = context.propsValue.name;
+      }
+
+      const result = await client.lists.tagSearch(
+        context.propsValue.list_id!,
+        options
+      );
+
+      return {
+        success: true,
+        list_id: context.propsValue.list_id,
+        search_query: context.propsValue.name || 'All tags',
+        tags: result.tags,
+        total_items: result.total_items,
+        found_tags: result.tags.length,
+      };
+    } catch (error: any) {
+      throw new Error(`Failed to find tag: ${error.message || JSON.stringify(error)}`);
+    }
+  },
+});

package/src/lib/actions/get-campaign-report.ts

@@ -0,0 +1,204 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { mailchimpAuth } from '../..';
+import { mailchimpCommon } from '../common';
+import mailchimp from '@mailchimp/mailchimp_marketing';
+import { MailchimpClient, CampaignReportOptions } from '../common/types';
+
+export const getCampaignReport = createAction({
+  auth: mailchimpAuth,
+  name: 'get_campaign_report',
+  displayName: 'Get Campaign Report',
+  description: 'Get comprehensive report details for a specific sent campaign including opens, clicks, bounces, and performance metrics',
+  audience: 'both',
+  aiMetadata: { description: 'Retrieves the analytics report for a single sent campaign by campaign ID, covering opens, clicks, bounces, unsubscribes, and engagement metrics; optional field include/exclude lists narrow the payload. Use to read performance for a campaign that has already been sent. Read-only and idempotent. Returns a not-found result if the campaign has not been sent or the ID is wrong.', idempotent: true },
+  props: {
+    campaign_id: mailchimpCommon.mailChimpCampaignIdDropdown,
+    fields: Property.LongText({
+      displayName: 'Include Fields',
+      description: 'Comma-separated list of fields to return (e.g., "opens.unique_opens,clicks.click_rate")',
+      required: false,
+    }),
+    exclude_fields: Property.LongText({
+      displayName: 'Exclude Fields',
+      description: 'Comma-separated list of fields to exclude (e.g., "timeseries,_links")',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const accessToken = getAccessTokenOrThrow(context.auth);
+    const server = await mailchimpCommon.getMailChimpServerPrefix(accessToken);
+    
+    const client = mailchimp as unknown as MailchimpClient;
+    client.setConfig({
+      accessToken: accessToken,
+      server: server,
+    });
+
+    try {
+      const options: CampaignReportOptions = {};
+      
+      if (context.propsValue.fields && context.propsValue.fields.trim()) {
+        options.fields = context.propsValue.fields.trim();
+      }
+      
+      if (context.propsValue.exclude_fields && context.propsValue.exclude_fields.trim()) {
+        options.exclude_fields = context.propsValue.exclude_fields.trim();
+      }
+
+      const report = await client.reports.getCampaignReport(context.propsValue.campaign_id!, options);
+
+      return {
+        success: true,
+        report: {
+          id: report.id,
+          campaign_title: report.campaign_title,
+          type: report.type,
+          list_id: report.list_id,
+          list_is_active: report.list_is_active,
+          list_name: report.list_name,
+          subject_line: report.subject_line,
+          preview_text: report.preview_text,
+          emails_sent: report.emails_sent,
+          abuse_reports: report.abuse_reports,
+          unsubscribed: report.unsubscribed,
+          send_time: report.send_time,
+          rss_last_send: report.rss_last_send,
+          bounces: report.bounces,
+          forwards: report.forwards,
+          opens: report.opens,
+          clicks: report.clicks,
+          facebook_likes: report.facebook_likes,
+          industry_stats: report.industry_stats,
+          list_stats: report.list_stats,
+          ab_split: report.ab_split,
+          timewarp: report.timewarp,
+          timeseries: report.timeseries,
+          share_report: report.share_report,
+          ecommerce: report.ecommerce,
+          delivery_status: report.delivery_status,
+          _links: report._links,
+        },
+        summary: {
+          campaign_title: report.campaign_title,
+          subject_line: report.subject_line,
+          emails_sent: report.emails_sent,
+          unique_opens: report.opens?.unique_opens || 0,
+          unique_clicks: report.clicks?.unique_clicks || 0,
+          open_rate: report.opens?.open_rate || 0,
+          click_rate: report.clicks?.click_rate || 0,
+          bounce_rate: report.bounces ? ((report.bounces.hard_bounces + report.bounces.soft_bounces) / report.emails_sent * 100) : 0,
+          unsub_rate: report.unsubscribed ? (report.unsubscribed / report.emails_sent * 100) : 0,
+          abuse_rate: report.abuse_reports ? (report.abuse_reports / report.emails_sent * 100) : 0,
+        },
+        performance_metrics: {
+          opens: {
+            total: report.opens?.opens_total || 0,
+            unique: report.opens?.unique_opens || 0,
+            rate: report.opens?.open_rate || 0,
+            last_open: report.opens?.last_open,
+            proxy_excluded: {
+              total: report.opens?.proxy_excluded_opens || 0,
+              unique: report.opens?.proxy_excluded_unique_opens || 0,
+              rate: report.opens?.proxy_excluded_open_rate || 0,
+            },
+          },
+          clicks: {
+            total: report.clicks?.clicks_total || 0,
+            unique: report.clicks?.unique_clicks || 0,
+            unique_subscribers: report.clicks?.unique_subscriber_clicks || 0,
+            rate: report.clicks?.click_rate || 0,
+            last_click: report.clicks?.last_click,
+          },
+          bounces: {
+            hard: report.bounces?.hard_bounces || 0,
+            soft: report.bounces?.soft_bounces || 0,
+            syntax_errors: report.bounces?.syntax_errors || 0,
+            total: (report.bounces?.hard_bounces || 0) + (report.bounces?.soft_bounces || 0) + (report.bounces?.syntax_errors || 0),
+          },
+          engagement: {
+            forwards: {
+              count: report.forwards?.forwards_count || 0,
+              opens: report.forwards?.forwards_opens || 0,
+            },
+            facebook_likes: {
+              recipient_likes: report.facebook_likes?.recipient_likes || 0,
+              unique_likes: report.facebook_likes?.unique_likes || 0,
+              facebook_likes: report.facebook_likes?.facebook_likes || 0,
+            },
+          },
+        },
+        industry_comparison: report.industry_stats ? {
+          industry_type: report.industry_stats.type,
+          open_rate: report.industry_stats.open_rate,
+          click_rate: report.industry_stats.click_rate,
+          bounce_rate: report.industry_stats.bounce_rate,
+          unopen_rate: report.industry_stats.unopen_rate,
+          unsub_rate: report.industry_stats.unsub_rate,
+          abuse_rate: report.industry_stats.abuse_rate,
+        } : null,
+        list_performance: report.list_stats ? {
+          subscription_rate: report.list_stats.sub_rate,
+          unsubscription_rate: report.list_stats.unsub_rate,
+          open_rate: report.list_stats.open_rate,
+          proxy_excluded_open_rate: report.list_stats.proxy_excluded_open_rate,
+          click_rate: report.list_stats.click_rate,
+        } : null,
+        ecommerce_data: report.ecommerce ? {
+          total_orders: report.ecommerce.total_orders,
+          total_spent: report.ecommerce.total_spent,
+          total_revenue: report.ecommerce.total_revenue,
+          currency_code: report.ecommerce.currency_code,
+        } : null,
+        delivery_status: report.delivery_status ? {
+          enabled: report.delivery_status.enabled,
+          can_cancel: report.delivery_status.can_cancel,
+          status: report.delivery_status.status,
+          emails_sent: report.delivery_status.emails_sent,
+          emails_canceled: report.delivery_status.emails_canceled,
+        } : null,
+        ab_split_data: report.ab_split ? {
+          group_a: {
+            bounces: report.ab_split.a?.bounces || 0,
+            abuse_reports: report.ab_split.a?.abuse_reports || 0,
+            unsubs: report.ab_split.a?.unsubs || 0,
+            recipient_clicks: report.ab_split.a?.recipient_clicks || 0,
+            forwards: report.ab_split.a?.forwards || 0,
+            forwards_opens: report.ab_split.a?.forwards_opens || 0,
+            opens: report.ab_split.a?.opens || 0,
+            last_open: report.ab_split.a?.last_open,
+            unique_opens: report.ab_split.a?.unique_opens || 0,
+          },
+          group_b: {
+            bounces: report.ab_split.b?.bounces || 0,
+            abuse_reports: report.ab_split.b?.abuse_reports || 0,
+            unsubs: report.ab_split.b?.unsubs || 0,
+            recipient_clicks: report.ab_split.b?.recipient_clicks || 0,
+            forwards: report.ab_split.b?.forwards || 0,
+            forwards_opens: report.ab_split.b?.forwards_opens || 0,
+            opens: report.ab_split.b?.opens || 0,
+            last_open: report.ab_split.b?.last_open,
+            unique_opens: report.ab_split.b?.unique_opens || 0,
+          },
+        } : null,
+        timewarp_data: report.timewarp || [],
+        timeseries_data: report.timeseries || [],
+        share_report: report.share_report ? {
+          share_url: report.share_report.share_url,
+          share_password: report.share_report.share_password,
+        } : null,
+      };
+    } catch (error: any) {
+      if (error.status === 404) {
+        return {
+          success: false,
+          error: 'Campaign report not found',
+          message: 'The requested campaign report could not be found. Make sure the campaign has been sent and the campaign ID is correct.',
+          detail: error.detail || 'The requested resource could not be found',
+        };
+      }
+      
+      throw new Error(`Failed to get campaign report: ${error.message || JSON.stringify(error)}`);
+    }
+  },
+});