@promptbook/cli 0.104.0-9 → 0.104.0

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddress.test.ts.todo

@@ -1,108 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { parseEmailAddress } from './parseEmailAddress';
-
-describe('how parseEmailAddress works', () => {
-    it('should work with simple email', () => {
-        expect(parseEmailAddress('pavol@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'pavol@webgpt.cz',
-            fullEmail: 'pavol@webgpt.cz',
-            plus: [],
-        });
-        expect(parseEmailAddress('jirka@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'jirka@webgpt.cz',
-            fullEmail: 'jirka@webgpt.cz',
-            plus: [],
-        });
-        expect(parseEmailAddress('tomas@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'tomas@webgpt.cz',
-            fullEmail: 'tomas@webgpt.cz',
-            plus: [],
-        });
-    });
-
-    it('should work with fullname', () => {
-        expect(parseEmailAddress('Pavol Hejný <pavol@webgpt.cz>')).toEqual({
-            fullName: 'Pavol Hejný',
-            baseEmail: 'pavol@webgpt.cz',
-            fullEmail: 'pavol@webgpt.cz',
-            plus: [],
-        });
-        expect(parseEmailAddress('Jirka <jirka@webgpt.cz>')).toEqual({
-            fullName: 'Jirka',
-            baseEmail: 'jirka@webgpt.cz',
-            fullEmail: 'jirka@webgpt.cz',
-            plus: [],
-        });
-        expect(parseEmailAddress('"Tomáš Studeník" <tomas@webgpt.cz>')).toEqual({
-            fullName: 'Tomáš Studeník',
-            baseEmail: 'tomas@webgpt.cz',
-            fullEmail: 'tomas@webgpt.cz',
-            plus: [],
-        });
-    });
-
-    it('should work with plus', () => {
-        expect(parseEmailAddress('pavol+test@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'pavol@webgpt.cz',
-            fullEmail: 'pavol+test@webgpt.cz',
-            plus: ['test'],
-        });
-        expect(parseEmailAddress('jirka+test@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'jirka@webgpt.cz',
-            fullEmail: 'jirka+test@webgpt.cz',
-            plus: ['test'],
-        });
-        expect(parseEmailAddress('tomas+test+ainautes@webgpt.cz')).toEqual({
-            fullName: null,
-            baseEmail: 'tomas@webgpt.cz',
-            fullEmail: 'tomas+test+ainautes@webgpt.cz',
-            plus: ['test', 'ainautes'],
-        });
-    });
-
-    it('should work with both fullname and plus', () => {
-        expect(parseEmailAddress('Pavol Hejný <pavol+foo@webgpt.cz>')).toEqual({
-            fullName: 'Pavol Hejný',
-            baseEmail: 'pavol@webgpt.cz',
-            fullEmail: 'pavol+foo@webgpt.cz',
-            plus: ['foo'],
-        });
-        expect(parseEmailAddress('Jirka <jirka+test@webgpt.cz>')).toEqual({
-            fullName: 'Jirka',
-            baseEmail: 'jirka@webgpt.cz',
-            fullEmail: 'jirka+test@webgpt.cz',
-            plus: ['test'],
-        });
-        expect(parseEmailAddress('"Tomáš Studeník" <tomas+test+ainautes@webgpt.cz>')).toEqual({
-            fullName: 'Tomáš Studeník',
-            baseEmail: 'tomas@webgpt.cz',
-            fullEmail: 'tomas+test+ainautes@webgpt.cz',
-            plus: ['test', 'ainautes'],
-        });
-    });
-
-    it('throws on multiple adresses', () => {
-        expect(() => parseEmailAddress('Pavol <pavol@webgpt.cz>, Jirka <jirka@webgpt.cz>')).toThrowError(
-            /Seems like you are trying to parse multiple email addresses/,
-        );
-    });
-
-    it('throws on invalid email adresses', () => {
-        expect(() => parseEmailAddress('')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný <>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný <@webgpt.cz>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný <webgpt.cz>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný <pavol@>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddress('Pavol Hejný <a@b>')).toThrowError(/Invalid email address/);
-    });
-});
-
-/**
- * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
- */

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddress.ts

@@ -1,62 +0,0 @@
-import type { string_email } from '@promptbook-local/types';
-import { isValidEmail, spaceTrim } from '@promptbook-local/utils';
-import { EmailAddress } from '../Email';
-
-/**
- * Parses the email address into its components
- */
-export function parseEmailAddress(value: string_email): EmailAddress {
-    if (value.includes(',')) {
-        throw new Error('Seems like you are trying to parse multiple email addresses, use parseEmailAddresses instead');
-    }
-
-    let fullName = value.match(/^(?:"?([^"]+)"?|[^<]+)\s*</)?.[1] ?? null;
-
-    if (fullName !== null) {
-        fullName = fullName.trim();
-    }
-
-    const fullEmail = value.match(/<([^>]+)>/)?.[1] ?? value;
-    const plus: Array<string> = [];
-
-    if (!isValidEmail(fullEmail)) {
-        throw new Error(
-            spaceTrim(
-                (block) => `
-                    Invalid email address "${fullEmail}"
-
-                    Parsed:
-                    ${block(JSON.stringify({ fullName, fullEmail, plus }, null, 4))}
-                
-                `,
-            ),
-        );
-    }
-
-    if (fullEmail.includes('+')) {
-        const [user, domain] = fullEmail.split('@');
-
-        if (!user || !domain) {
-            throw new Error('Can not parse email address');
-            //               <- TODO: ShouldNeverHappenError
-        }
-
-        const userParts = user.split('+');
-        userParts.shift();
-
-        plus.push(...userParts);
-    }
-
-    let baseEmail = fullEmail;
-
-    for (const plusItem of plus) {
-        baseEmail = baseEmail.replace(`+${plusItem}`, '');
-    }
-
-    return {
-        fullName,
-        baseEmail,
-        fullEmail,
-        plus,
-    };
-}

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddresses.test.ts.todo

@@ -1,117 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { parseEmailAddresses } from './parseEmailAddresses';
-
-describe('how parseEmailAddresses works', () => {
-    it('should work with single email', () => {
-        expect(parseEmailAddresses('pavol@webgpt.cz')).toEqual([
-            {
-                fullName: null,
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol@webgpt.cz',
-                plus: [],
-            },
-        ]);
-    });
-
-    it('should work with simple emails', () => {
-        expect(parseEmailAddresses('pavol@webgpt.cz, jirka@webgpt.cz, tomas@webgpt.cz')).toEqual([
-            {
-                fullName: null,
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol@webgpt.cz',
-                plus: [],
-            },
-            {
-                fullName: null,
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka@webgpt.cz',
-                plus: [],
-            },
-            {
-                fullName: null,
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas@webgpt.cz',
-                plus: [],
-            },
-        ]);
-    });
-
-    it('should work with fullname', () => {
-        expect(
-            parseEmailAddresses(
-                'Pavol Hejný <pavol@webgpt.cz>, Jirka <jirka@webgpt.cz>, "Tomáš Studeník" <tomas@webgpt.cz>',
-            ),
-        ).toEqual([
-            {
-                fullName: 'Pavol Hejný',
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol@webgpt.cz',
-                plus: [],
-            },
-            {
-                fullName: 'Jirka',
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka@webgpt.cz',
-                plus: [],
-            },
-            {
-                fullName: 'Tomáš Studeník',
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas@webgpt.cz',
-                plus: [],
-            },
-        ]);
-    });
-
-    it('not confused by comma', () => {
-        expect(parseEmailAddresses(', pavol@webgpt.cz, ')).toEqual([
-            {
-                fullName: null,
-                fullEmail: 'pavol@webgpt.cz',
-                baseEmail: 'pavol@webgpt.cz',
-                plus: [],
-            },
-        ]);
-    });
-
-    it('works on real-life example', () => {
-        expect(
-            parseEmailAddresses(
-                '"bob" <bob@bot.webgpt.cz>, "pavolto" <pavol+to@ptbk.io>, "Pavol" <pavol@collboard.com>',
-            ),
-        ).toEqual([
-            {
-                fullName: 'bob',
-                fullEmail: 'bob@bot.webgpt.cz',
-                baseEmail: 'bob@bot.webgpt.cz',
-                plus: [],
-            },
-            {
-                fullName: 'pavolto',
-                fullEmail: 'pavol+to@ptbk.io',
-                baseEmail: 'pavol@ptbk.io',
-                plus: ['to'],
-            },
-            {
-                fullName: 'Pavol',
-                fullEmail: 'pavol@collboard.com',
-                baseEmail: 'pavol@collboard.com',
-                plus: [],
-            },
-        ]);
-    });
-
-    it('throws on invalid email adresses', () => {
-        expect(() => parseEmailAddresses('Pavol, Hejný')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddresses('Pavol Hejný <>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddresses('Pavol Hejný, <@webgpt.cz>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddresses('Pavol Hejný <webgpt.cz>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddresses('Pavol Hejný <pavol@>')).toThrowError(/Invalid email address/);
-        expect(() => parseEmailAddresses('Pavol Hejný <a@b>,')).toThrowError(/Invalid email address/);
-    });
-});
-
-
-/**
- * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
- */

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddresses.ts

@@ -1,19 +0,0 @@
-import type { string_emails } from '@promptbook-local/types';
-import { spaceTrim } from 'spacetrim';
-import type { EmailAddress } from '../Email';
-import { parseEmailAddress } from './parseEmailAddress';
-
-/**
- * Parses the email addresses into its components
- */
-export function parseEmailAddresses(value: string_emails): Array<EmailAddress> {
-    const emailAddresses = value
-        .split(',')
-        .map((email) => spaceTrim(email))
-        .filter((email) => email !== '')
-        .map((email) => parseEmailAddress(email));
-
-    // console.log('parseEmailAddresses', value, '->', emailAddresses);
-
-    return emailAddresses;
-}

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddress.test.ts.todo

@@ -1,119 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { stringifyEmailAddress } from './stringifyEmailAddress';
-
-describe('how stringifyEmailAddress works', () => {
-    it('should work with simple email', () => {
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('pavol@webgpt.cz');
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('jirka@webgpt.cz');
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('tomas@webgpt.cz');
-    });
-
-    it('should work with fullname', () => {
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Pavol Hejný',
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('"Pavol Hejný" <pavol@webgpt.cz>');
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Jirka',
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('"Jirka" <jirka@webgpt.cz>');
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Tomáš Studeník',
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas@webgpt.cz',
-                plus: [],
-            }),
-        ).toBe('"Tomáš Studeník" <tomas@webgpt.cz>');
-    });
-
-    it('should work with plus', () => {
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol+test@webgpt.cz',
-                plus: ['test'],
-            }),
-        ).toBe('pavol+test@webgpt.cz');
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka+test@webgpt.cz',
-                plus: ['test'],
-            }),
-        ).toBe('jirka+test@webgpt.cz');
-        expect(
-            stringifyEmailAddress({
-                fullName: null,
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas+test+ainautes@webgpt.cz',
-                plus: ['test', 'ainautes'],
-            }),
-        ).toBe('tomas+test+ainautes@webgpt.cz');
-    });
-
-    it('should work with both fullname and plus', () => {
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Pavol Hejný',
-                baseEmail: 'pavol@webgpt.cz',
-                fullEmail: 'pavol+test@webgpt.cz',
-                plus: ['test'],
-            }),
-        ).toBe('"Pavol Hejný" <pavol+test@webgpt.cz>');
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Jirka',
-                baseEmail: 'jirka@webgpt.cz',
-                fullEmail: 'jirka+test@webgpt.cz',
-                plus: ['test'],
-            }),
-        ).toBe('"Jirka" <jirka+test@webgpt.cz>');
-        expect(
-            stringifyEmailAddress({
-                fullName: 'Tomáš Studeník',
-                baseEmail: 'tomas@webgpt.cz',
-                fullEmail: 'tomas+test+ainautes@webgpt.cz',
-                plus: ['test', 'ainautes'],
-            }),
-        ).toBe('"Tomáš Studeník" <tomas+test+ainautes@webgpt.cz>');
-    });
-
-    // TODO: [🎾] Implement and test here escaping
-});
-
-
-/**
- * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
- */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddress.ts

@@ -1,19 +0,0 @@
-import type { string_email } from '@promptbook-local/types';
-import type { EmailAddress } from '../Email';
-
-/**
- * Makes string email from EmailAddress
- */
-export function stringifyEmailAddress(emailAddress: EmailAddress): string_email {
-    const { fullEmail, fullName } = emailAddress;
-
-    if (fullName !== null) {
-        return `"${fullName}" <${fullEmail}>`;
-    }
-
-    return fullEmail;
-}
-
-/**
- * TODO: [🎾] Implement and test here escaping
- */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddresses.test.ts.todo

@@ -1,74 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { stringifyEmailAddresses } from './stringifyEmailAddresses';
-
-describe('how stringifyEmailAddresses works', () => {
-    it('should work with single email', () => {
-        expect(
-            stringifyEmailAddresses([
-                {
-                    fullName: null,
-                    baseEmail: 'pavol@webgpt.cz',
-                    fullEmail: 'pavol@webgpt.cz',
-                    plus: [],
-                },
-            ]),
-        ).toEqual('pavol@webgpt.cz');
-    });
-
-    it('should work with simple emails', () => {
-        expect(
-            stringifyEmailAddresses([
-                {
-                    fullName: null,
-                    baseEmail: 'pavol@webgpt.cz',
-                    fullEmail: 'pavol@webgpt.cz',
-                    plus: [],
-                },
-                {
-                    fullName: null,
-                    baseEmail: 'jirka@webgpt.cz',
-                    fullEmail: 'jirka@webgpt.cz',
-                    plus: [],
-                },
-                {
-                    fullName: null,
-                    baseEmail: 'tomas@webgpt.cz',
-                    fullEmail: 'tomas@webgpt.cz',
-                    plus: [],
-                },
-            ]),
-        ).toEqual('pavol@webgpt.cz, jirka@webgpt.cz, tomas@webgpt.cz');
-    });
-
-    it('should work with fullname', () => {
-        expect(
-            stringifyEmailAddresses([
-                {
-                    fullName: 'Pavol Hejný',
-                    baseEmail: 'pavol@webgpt.cz',
-                    fullEmail: 'pavol@webgpt.cz',
-                    plus: [],
-                },
-                {
-                    fullName: 'Jiří Jahn',
-                    baseEmail: 'jirka@webgpt.cz',
-                    fullEmail: 'jirka@webgpt.cz',
-                    plus: [],
-                },
-                {
-                    fullName: 'Tomáš Studeník',
-                    baseEmail: 'tomas@webgpt.cz',
-                    fullEmail: 'tomas@webgpt.cz',
-                    plus: [],
-                },
-            ]),
-        ).toEqual('"Pavol Hejný" <pavol@webgpt.cz>, "Jiří Jahn" <jirka@webgpt.cz>, "Tomáš Studeník" <tomas@webgpt.cz>');
-    });
-
-    // TODO: [🎾] Implement and test here escaping
-});
-
-
-/**
- * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
- */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddresses.ts

@@ -1,14 +0,0 @@
-import type { string_emails } from '@promptbook-local/types';
-import type { EmailAddress } from '../Email';
-import { stringifyEmailAddress } from './stringifyEmailAddress';
-
-/**
- * Makes string email from multiple EmailAddress
- */
-export function stringifyEmailAddresses(emailAddresses: Array<EmailAddress>): string_emails {
-    return emailAddresses.map((emailAddress) => stringifyEmailAddress(emailAddress)).join(', ');
-}
-
-/**
- * TODO: [🎾] Implement and test here escaping
- */

package/apps/agents-server/src/message-providers/email/sendgrid/SendgridMessageProvider.ts

@@ -1,44 +0,0 @@
-import { removeMarkdownFormatting } from '@promptbook-local/markdown-utils';
-import type { really_any } from '@promptbook-local/types';
-import sendgridEmailClient from '@sendgrid/mail';
-import { marked } from 'marked';
-import { MessageProvider } from '../../interfaces/MessageProvider';
-import { OutboundEmail } from '../_common/Email';
-import { parseEmailAddress } from '../_common/utils/parseEmailAddress';
-
-export class SendgridMessageProvider implements MessageProvider {
-    constructor(private readonly apiKey: string) {
-        sendgridEmailClient.setApiKey(this.apiKey);
-    }
-
-    public async send(message: OutboundEmail): Promise<really_any> {
-        const sender = message.sender;
-        const recipients = (Array.isArray(message.recipients) ? message.recipients : [message.recipients]).filter(
-            Boolean,
-        ) as really_any[];
-
-        const text = removeMarkdownFormatting(message.content);
-        const html = await marked.parse(message.content);
-
-        const { fullEmail, fullName } = parseEmailAddress(sender);
-
-        const response = await sendgridEmailClient.send({
-            from: {
-                email: fullEmail,
-                name: fullName || undefined,
-            },
-            to: recipients.map((r) => {
-                const { fullEmail, fullName } = parseEmailAddress(r.email || r.baseEmail || r);
-                return {
-                    email: fullEmail,
-                    name: r.name || fullName || undefined,
-                };
-            }),
-            subject: message.metadata?.subject || 'No Subject',
-            text,
-            html,
-        });
-
-        return response;
-    }
-}

package/apps/agents-server/src/message-providers/email/sendgrid/parseInboundSendgridEmail.ts

@@ -1,49 +0,0 @@
-import { string_markdown } from '@promptbook-local/types';
-import { simpleParser } from 'mailparser';
-import TurndownService from 'turndown';
-import { extractBodyContentFromHtml } from '../../../utils/content/extractBodyContentFromHtml';
-import type { InboundEmail } from '../_common/Email';
-import { parseEmailAddress } from '../_common/utils/parseEmailAddress';
-import { parseEmailAddresses } from '../_common/utils/parseEmailAddresses';
-
-/**
- * Function parseInboundSendgridEmail will parse raw inbound email from Sendgrid and return Email object
- */
-export async function parseInboundSendgridEmail(rawEmail: string): Promise<InboundEmail> {
-    const parsedEmail = await simpleParser(rawEmail);
-
-    const toArray = !Array.isArray(parsedEmail.to)
-        ? parsedEmail.to === undefined
-            ? []
-            : [parsedEmail.to]
-        : parsedEmail.to;
-    const to = toArray.flatMap((_) => parseEmailAddresses(_.text));
-
-    const ccArray = !Array.isArray(parsedEmail.cc)
-        ? parsedEmail.cc === undefined
-            ? []
-            : [parsedEmail.cc]
-        : parsedEmail.cc;
-    const cc = ccArray.flatMap((_) => parseEmailAddresses(_.text));
-
-    const turndownService = new TurndownService();
-
-    const content = (parsedEmail.html
-        ? turndownService.turndown(extractBodyContentFromHtml(parsedEmail.html))
-        : parsedEmail.text || '') as string_markdown;
-
-    const email: InboundEmail = {
-        channel: 'EMAIL',
-        direction: 'INBOUND',
-        sender: parseEmailAddress(parsedEmail.from?.text || '').fullEmail,
-        recipients: to.map((_) => _.fullEmail),
-        cc,
-        subject: parsedEmail.subject || '',
-        content,
-        attachments: [
-            /* <- TODO: [📯] Parse attachments */
-        ],
-    };
-
-    return email;
-}

package/apps/agents-server/src/message-providers/email/zeptomail/ZeptomailMessageProvider.ts

@@ -1,51 +0,0 @@
-import { removeMarkdownFormatting } from '@promptbook-local/markdown-utils';
-import type { really_any } from '@promptbook-local/types';
-import { marked } from 'marked';
-// @ts-expect-error: Zeptomail types are not resolving correctly
-import { SendMailClient } from 'zeptomail';
-import { MessageProvider } from '../../interfaces/MessageProvider';
-import { OutboundEmail } from '../_common/Email';
-
-export class ZeptomailMessageProvider implements MessageProvider {
-    constructor(private readonly apiKey: string) {}
-
-    public async send(message: OutboundEmail): Promise<really_any> {
-        try {
-            const client = new SendMailClient({ url: 'api.zeptomail.com/', token: this.apiKey });
-
-            const sender = message.sender as really_any;
-            const recipients = (Array.isArray(message.recipients) ? message.recipients : [message.recipients]).filter(
-                Boolean,
-            ) as really_any[];
-
-            const textbody = removeMarkdownFormatting(message.content);
-            const htmlbody = await marked.parse(message.content);
-
-            const response = await client.sendMail({
-                from: {
-                    address: sender.email || sender.baseEmail || sender,
-                    name: sender.name || sender.fullName || undefined,
-                },
-                to: recipients.map((r) => ({
-                    email_address: {
-                        address: r.email || r.baseEmail || r,
-                        name: r.name || r.fullName || undefined,
-                    },
-                })),
-                subject: message.metadata?.subject || 'No Subject',
-                textbody,
-                htmlbody,
-                track_clicks: true,
-                track_opens: true,
-            });
-
-            return response;
-        } catch (raw: really_any) {
-            if (!('error' in raw)) {
-                throw raw;
-            }
-
-            throw new Error(raw.error.message, raw.error.details);
-        }
-    }
-}