@promptbook/cli 0.104.0-3 → 0.104.0-4

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/zeptomail/ZeptomailMessageProvider.ts

@@ -0,0 +1,43 @@
+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> {
+        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;
+    }
+}

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/utils/messages/sendMessage.ts

@@ -0,0 +1,91 @@
+import type { really_any } from '@promptbook-local/types';
+import { $getTableName } from '../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
+import { EMAIL_PROVIDERS } from '../../message-providers';
+import { OutboundEmail } from '../../message-providers/email/_common/Email';
+
+/**
+ * Sends a message
+ */
+export async function sendMessage(message: OutboundEmail): Promise<void> {
+    const supabase = await $provideSupabaseForServer();
+    // @ts-expect-error: Tables are not yet in types
+    const messageTable = await $getTableName('Message');
+    // @ts-expect-error: Tables are not yet in types
+    const messageSendAttemptTable = await $getTableName('MessageSendAttempt');
+
+    // 1. Insert message
+    const { data: insertedMessage, error: insertError } = await supabase
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .from(messageTable as any)
+        .insert({
+            channel: message.channel || 'UNKNOWN',
+            direction: message.direction || 'OUTBOUND',
+            sender: message.sender,
+            recipients: message.recipients,
+            content: message.content,
+            threadId: message.threadId,
+            metadata: message.metadata,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } as any)
+        .select()
+        .single();
+
+    if (insertError) {
+        throw new Error(`Failed to insert message: ${insertError.message}`);
+    }
+
+    if (!insertedMessage) {
+        throw new Error('Failed to insert message: No data returned');
+    }
+
+    // 2. If outbound and email, try to send
+    if (message.direction === 'OUTBOUND' && message.channel === 'EMAIL') {
+        const providers = Object.keys(EMAIL_PROVIDERS);
+
+        if (providers.length === 0) {
+            console.warn('No email providers configured');
+            return;
+        }
+
+        let isSent = false;
+
+        for (const providerName of providers) {
+            const provider = EMAIL_PROVIDERS[providerName];
+            let isSuccessful = false;
+            let raw: really_any = null;
+
+            try {
+                raw = await provider.send(message);
+                isSuccessful = true;
+                isSent = true;
+            } catch (error) {
+                console.error(`Failed to send email via ${providerName}`, error);
+                raw = { error: error instanceof Error ? error.message : String(error) };
+            }
+
+            // 3. Log attempt
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await supabase.from(messageSendAttemptTable as any).insert({
+                // @ts-expect-error: insertedMessage is any
+                messageId: insertedMessage.id,
+                providerName,
+                isSuccessful,
+                raw,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+
+            if (isSuccessful) {
+                break;
+            }
+        }
+
+        if (!isSent) {
+            throw new Error('Failed to send email via any provider');
+        }
+    }
+}
+
+/**
+ * TODO: !!!! Move to `message-providers` and rename `message-providers` -> `messages`
+ */

package/apps/agents-server/src/utils/normalization/filenameToPrompt.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from '@jest/globals';
+import { filenameToPrompt } from './filenameToPrompt';
+
+describe('how filenameToPrompt works', () => {
+    it('will convert filename with dashes', () => {
+        expect(filenameToPrompt('cat-sitting-on-keyboard.png')).toEqual('Cat sitting on keyboard');
+        expect(filenameToPrompt('hello-world.jpg')).toEqual('Hello world');
+    });
+
+    it('will convert filename with underscores', () => {
+        expect(filenameToPrompt('cat_sitting_on_keyboard.png')).toEqual('Cat sitting on keyboard');
+        expect(filenameToPrompt('hello_world.jpg')).toEqual('Hello world');
+    });
+
+    it('will convert filename with mixed separators', () => {
+        expect(filenameToPrompt('cat-sitting_on-keyboard.png')).toEqual('Cat sitting on keyboard');
+    });
+
+    it('will handle single word filename', () => {
+        expect(filenameToPrompt('cat.png')).toEqual('Cat');
+        expect(filenameToPrompt('HELLO.jpg')).toEqual('HELLO');
+    });
+
+    it('will handle filename without extension', () => {
+        expect(filenameToPrompt('cat-sitting-on-keyboard')).toEqual('Cat sitting on keyboard');
+    });
+
+    it('will handle filename with multiple dots', () => {
+        expect(filenameToPrompt('cat.sitting.on.keyboard.png')).toEqual('Cat.sitting.on.keyboard');
+    });
+
+    it('will handle capitalized words after first word', () => {
+        expect(filenameToPrompt('Cat-Sitting-On-Keyboard.png')).toEqual('Cat sitting on keyboard');
+        expect(filenameToPrompt('HELLO-WORLD.png')).toEqual('HELLO world');
+    });
+});

package/apps/agents-server/src/utils/normalization/filenameToPrompt.ts

@@ -1,4 +1,4 @@
-import { capitalize } from '../../../../../src/utils/normalization/capitalize';
+import { capitalize } from '@promptbook/utils';
 
 /**
  * Converts a filename like "cat-sitting-on-keyboard.png" to a prompt like "Cat sitting on keyboard"
@@ -15,7 +15,11 @@ export function filenameToPrompt(filename: string): string {
 
     // Capitalize each word
     const words = withSpaces.split(' ');
-    const capitalizedWords = words.map(word => capitalize(word));
+    const capitalizedWords = words.map((word, index) => (index === 0 ? capitalize(word) : word.toLowerCase()));
 
     return capitalizedWords.join(' ');
 }
+
+/**
+ * TODO: [🧠][🏰] Make standard normalization function exported from `@promptbook/utils`
+ */

package/esm/index.es.js

@@ -47,7 +47,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.104.0-3';
+const PROMPTBOOK_ENGINE_VERSION = '0.104.0-4';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3721,6 +3721,7 @@ class RemoteLlmExecutionTools {
     }
 }
 /**
+ * TODO: !!!! Deprecate pipeline server and all of its components
  * TODO: Maybe use `$exportJson`
  * TODO: [🧠][🛍] Maybe not `isAnonymous: boolean` BUT `mode: 'ANONYMOUS'|'COLLECTION'`
  * TODO: [🍓] Allow to list compatible models with each variant
@@ -4249,6 +4250,9 @@ function cacheLlmTools(llmTools, options = {}) {
             case 'EMBEDDING':
                 promptResult = await llmTools.callEmbeddingModel(prompt);
                 break variant;
+            case 'IMAGE_GENERATION':
+                promptResult = await llmTools.callImageGenerationModel(prompt);
+                break variant;
             // <- case [🤖]:
             default:
                 throw new PipelineExecutionError(`Unknown model variant "${prompt.modelRequirements.modelVariant}"`);
@@ -4336,6 +4340,11 @@ function cacheLlmTools(llmTools, options = {}) {
             return /* not await */ callCommonModel(prompt);
         };
     }
+    if (llmTools.callImageGenerationModel !== undefined) {
+        proxyTools.callImageGenerationModel = async (prompt) => {
+            return /* not await */ callCommonModel(prompt);
+        };
+    }
     // <- Note: [🤖]
     return proxyTools;
 }
@@ -4524,6 +4533,15 @@ function countUsage(llmTools) {
             return promptResult;
         };
     }
+    if (llmTools.callImageGenerationModel !== undefined) {
+        proxyTools.callImageGenerationModel = async (prompt) => {
+            // console.info('[🚕] callImageGenerationModel through countTotalUsage');
+            const promptResult = await llmTools.callImageGenerationModel(prompt);
+            totalUsage = addUsage(totalUsage, promptResult.usage);
+            spending.next(promptResult.usage);
+            return promptResult;
+        };
+    }
     // <- Note: [🤖]
     return proxyTools;
 }
@@ -4646,6 +4664,12 @@ class MultipleLlmExecutionTools {
     callEmbeddingModel(prompt) {
         return this.callCommonModel(prompt);
     }
+    /**
+     * Calls the best available embedding model
+     */
+    callImageGenerationModel(prompt) {
+        return this.callCommonModel(prompt);
+    }
     // <- Note: [🤖]
     /**
      * Calls the best available model
@@ -4672,6 +4696,11 @@ class MultipleLlmExecutionTools {
                             continue llm;
                         }
                         return await llmExecutionTools.callEmbeddingModel(prompt);
+                    case 'IMAGE_GENERATION':
+                        if (llmExecutionTools.callImageGenerationModel === undefined) {
+                            continue llm;
+                        }
+                        return await llmExecutionTools.callImageGenerationModel(prompt);
                     // <- case [🤖]:
                     default:
                         throw new UnexpectedError(`Unknown model variant "${prompt.modelRequirements.modelVariant}" in ${llmExecutionTools.title}`);
@@ -7594,8 +7623,9 @@ async function executeAttempts(options) {
                                     $ongoingTaskResult.$resultString = $ongoingTaskResult.$completionResult.content;
                                     break variant;
                                 case 'EMBEDDING':
+                                case 'IMAGE_GENERATION':
                                     throw new PipelineExecutionError(spaceTrim$1((block) => `
-                                                Embedding model can not be used in pipeline
+                                                ${modelRequirements.modelVariant} model can not be used in pipeline
 
                                                 This should be catched during parsing