@promptbook/cli 0.104.0-1 → 0.104.0-11

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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,51 @@
+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);
+        }
+    }
+}

package/apps/agents-server/src/message-providers/index.ts

@@ -0,0 +1,13 @@
+import { SendgridMessageProvider } from './email/sendgrid/SendgridMessageProvider';
+import { ZeptomailMessageProvider } from './email/zeptomail/ZeptomailMessageProvider';
+import { MessageProvider } from './interfaces/MessageProvider';
+
+export const EMAIL_PROVIDERS: Record<string, MessageProvider> = {};
+
+if (process.env.ZEPTOMAIL_API_KEY) {
+    EMAIL_PROVIDERS['ZEPTOMAIL'] = new ZeptomailMessageProvider(process.env.ZEPTOMAIL_API_KEY);
+}
+
+if (process.env.SENDGRID_API_KEY) {
+    EMAIL_PROVIDERS['SENDGRID'] = new SendgridMessageProvider(process.env.SENDGRID_API_KEY);
+}

package/apps/agents-server/src/message-providers/interfaces/MessageProvider.ts

@@ -0,0 +1,11 @@
+import type { Message, really_any, string_email } from '@promptbook-local/types';
+
+export type MessageProvider = {
+    /**
+     * Sends a message through the provider
+     *
+     * @param message The message to send
+     * @returns Raw response from the provider
+     */
+    send(message: Message<string_email>): Promise<really_any>;
+};

package/apps/agents-server/src/middleware.ts

@@ -1,13 +1,15 @@
 import { TODO_any } from '@promptbook-local/types';
 import { createClient } from '@supabase/supabase-js';
 import { NextRequest, NextResponse } from 'next/server';
-import { SERVERS, SUPABASE_TABLE_PREFIX } from '../config';
+import { SERVERS } from '../config';
+import { $getTableName } from './database/$getTableName';
+import { RESERVED_PATHS } from './generated/reservedPaths';
 import { isIpAllowed } from './utils/isIpAllowed';
 
-// Note: Re-implementing normalizeTo_PascalCase to avoid importing from @promptbook-local/utils which might have Node.js dependencies
+// Note: Re-implementing normalizeTo_PascalCase to avoid importing from @promptbook-local/utils which might have Node.js dependencies !!!!
 function normalizeTo_PascalCase(text: string): string {
     return text
-        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => {
             return word.toUpperCase();
         })
         .replace(/\s+/g, '');
@@ -33,8 +35,12 @@ export async function middleware(req: NextRequest) {
     const host = req.headers.get('host');
 
     if (host) {
+        /*
+        Note: [🐔] This code was commented out because results of it are unused
+
         let tablePrefix = SUPABASE_TABLE_PREFIX;
 
+        
         if (SERVERS && SERVERS.length > 0) {
             // Logic mirrored from src/tools/$provideServer.ts
             if (SERVERS.some((server) => server === host)) {
@@ -44,6 +50,7 @@ export async function middleware(req: NextRequest) {
                 tablePrefix = `server_${serverName}_`;
             }
         }
+        */
 
         const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
         const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
@@ -58,7 +65,7 @@ export async function middleware(req: NextRequest) {
                 });
 
                 const { data } = await supabase
-                    .from(`${tablePrefix}Metadata`)
+                    .from(await $getTableName(`Metadata`))
                     .select('value')
                     .eq('key', 'RESTRICT_IP')
                     .single();
@@ -82,6 +89,9 @@ export async function middleware(req: NextRequest) {
         const token = authHeader.split(' ')[1];
 
         if (token.startsWith('ptbk_')) {
+            /*
+            Note: [🐔] This code was commented out because results of it are unused
+            
             const host = req.headers.get('host');
             let tablePrefix = SUPABASE_TABLE_PREFIX;
 
@@ -93,6 +103,7 @@ export async function middleware(req: NextRequest) {
                     tablePrefix = `server_${serverName}_`;
                 }
             }
+            */
 
             const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
             const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
@@ -107,7 +118,7 @@ export async function middleware(req: NextRequest) {
                     });
 
                     const { data } = await supabase
-                        .from(`${tablePrefix}ApiTokens`)
+                        .from(await $getTableName(`ApiTokens`))
                         .select('id')
                         .eq('token', token)
                         .eq('isRevoked', false)
@@ -186,22 +197,7 @@ export async function middleware(req: NextRequest) {
 
     if (
         potentialAgentName &&
-        ![
-            'agents',
-            'api',
-            'admin',
-            'docs',
-            'test',
-            'embed',
-            '_next',
-            'manifest.webmanifest',
-            'sw.js',
-            'favicon.ico',
-            'sitemap.xml',
-            'robots.txt',
-            'security.txt',
-            'humans.txt',
-        ].includes(potentialAgentName) &&
+        !RESERVED_PATHS.includes(potentialAgentName) &&
         !potentialAgentName.startsWith('.') &&
         // Note: Other static files are excluded by the matcher configuration below
         true
@@ -243,7 +239,7 @@ export async function middleware(req: NextRequest) {
                 let serverName = serverHost;
                 serverName = serverName.replace(/\.ptbk\.io$/, '');
                 serverName = normalizeTo_PascalCase(serverName);
-                const prefix = `server_${serverName}_`;
+                // const prefix = `server_${serverName}_`;
 
                 // Search for agent with matching META LINK
                 // agentProfile->links is an array of strings
@@ -256,7 +252,7 @@ export async function middleware(req: NextRequest) {
 
                 try {
                     const { data } = await supabase
-                        .from(`${prefix}Agent`)
+                        .from(await $getTableName(`Agent`))
                         .select('agentName')
                         .or(orFilter)
                         .limit(1)