@promptbook/cli 0.104.0-1 → 0.104.0-10

package/apps/agents-server/src/utils/handleChatCompletion.ts

@@ -2,10 +2,11 @@ import { $getTableName } from '@/src/database/$getTableName';
 import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
 import { $provideOpenAiAssistantExecutionToolsForServer } from '@/src/tools/$provideOpenAiAssistantExecutionToolsForServer';
-import { Agent, computeAgentHash, PROMPTBOOK_ENGINE_VERSION } from '@promptbook-local/core';
+import { Agent, computeAgentHash, parseAgentSource, PROMPTBOOK_ENGINE_VERSION } from '@promptbook-local/core';
 import { ChatMessage, ChatPromptResult, Prompt, string_book, TODO_any } from '@promptbook-local/types';
 import { computeHash } from '@promptbook-local/utils';
 import { NextRequest, NextResponse } from 'next/server';
+import { isAgentDeleted } from '../app/agents/[agentName]/_utils';
 import { validateApiKey } from './validateApiKey';
 
 export async function handleChatCompletion(
@@ -60,6 +61,19 @@ export async function handleChatCompletion(
             );
         }
 
+        // Check if agent is deleted
+        if (await isAgentDeleted(agentName)) {
+            return NextResponse.json(
+                {
+                    error: {
+                        message: 'This agent has been deleted. You can restore it from the Recycle Bin.',
+                        type: 'agent_deleted',
+                    },
+                },
+                { status: 410 }, // Gone - indicates the resource is no longer available
+            );
+        }
+
         const collection = await $provideAgentCollectionForServer();
         let agentSource: string_book;
         try {
@@ -99,7 +113,54 @@ export async function handleChatCompletion(
             );
         }
 
-        const openAiAssistantExecutionTools = await $provideOpenAiAssistantExecutionToolsForServer();
+        const agentHash = computeAgentHash(agentSource);
+        const supabase = $provideSupabaseForServer();
+        const { data: assistantCache } = await supabase
+            .from(await $getTableName('OpenAiAssistantCache'))
+            .select('assistantId')
+            .eq('agentHash', agentHash)
+            .single();
+
+        let openAiAssistantExecutionTools = await $provideOpenAiAssistantExecutionToolsForServer();
+
+        if (assistantCache?.assistantId) {
+            console.log(
+                `[🐱‍🚀] Reusing assistant ${assistantCache.assistantId} for agent ${agentName} (hash: ${agentHash})`,
+            );
+            openAiAssistantExecutionTools = openAiAssistantExecutionTools.getAssistant(assistantCache.assistantId);
+        } else {
+            console.log(`[🐱‍🚀] Creating NEW assistant for agent ${agentName} (hash: ${agentHash})`);
+            // Parse to get instructions and name
+            const parsed = parseAgentSource(agentSource);
+            const name = parsed.agentName || agentName;
+            // Extract PERSONA
+            const baseInstructions = parsed.personaDescription || 'You are a helpful assistant.';
+
+            // Note: Append context to instructions
+            const contextLines = agentSource.split('\n').filter((line) => line.startsWith('CONTEXT '));
+            const contextInstructions = contextLines.join('\n');
+            const instructions = contextInstructions
+                ? `${baseInstructions}\n\n${contextInstructions}`
+                : baseInstructions;
+
+            // Create assistant
+            const newAssistantTools = await openAiAssistantExecutionTools.createNewAssistant({
+                name,
+                instructions,
+                // knowledgeSources?
+            });
+
+            // Save to cache
+            const newAssistantId = newAssistantTools.assistantId;
+            if (newAssistantId) {
+                await supabase.from(await $getTableName('OpenAiAssistantCache')).insert({
+                    agentHash,
+                    assistantId: newAssistantId,
+                });
+                openAiAssistantExecutionTools = newAssistantTools;
+            }
+        }
+
         const agent = new Agent({
             agentSource,
             executionTools: {
@@ -108,7 +169,6 @@ export async function handleChatCompletion(
             isVerbose: true, // or false
         });
 
-        const agentHash = computeAgentHash(agentSource);
         const userAgent = request.headers.get('user-agent');
         const ip =
             request.headers.get('x-forwarded-for') ||
@@ -125,8 +185,9 @@ export async function handleChatCompletion(
         const previousMessages = threadMessages.slice(0, -1);
 
         const thread: ChatMessage[] = previousMessages.map((msg: TODO_any, index: number) => ({
+            // channel: 'PROMPTBOOK_CHAT',
             id: `msg-${index}`, // Placeholder ID
-            from: msg.role === 'assistant' ? 'agent' : 'user', // Mapping standard OpenAI roles
+            sender: msg.role === 'assistant' ? 'agent' : 'user', // Mapping standard OpenAI roles
             content: msg.content,
             isComplete: true,
             date: new Date(), // We don't have the real date, using current
@@ -138,7 +199,6 @@ export async function handleChatCompletion(
             content: lastMessage.content,
         };
 
-        const supabase = $provideSupabaseForServer();
         await supabase.from(await $getTableName('ChatHistory')).insert({
             createdAt: new Date().toISOString(),
             messageHash: computeHash(userMessageContent),

package/apps/agents-server/src/utils/messages/sendMessage.ts

@@ -0,0 +1,91 @@
+import type { really_any } from '@promptbook-local/types';
+import { serializeError } from '@promptbook-local/utils';
+import { assertsError } from '../../../../../src/errors/assertsError';
+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();
+
+    // 1. Insert message
+    const { data: insertedMessage, error: insertError } = await supabase
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .from(await $getTableName('Message'))
+        .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 {
+                console.log(`📤 Sending email via ${providerName}`);
+                raw = await provider.send(message);
+                isSuccessful = true;
+                isSent = true;
+            } catch (error) {
+                assertsError(error);
+                console.error(`Failed to send email via ${providerName}`, error);
+                raw = { error: serializeError(error) };
+            }
+
+            // 3. Log attempt
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await supabase.from(await $getTableName('MessageSendAttempt')).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/messagesAdmin.ts

@@ -0,0 +1,72 @@
+import type { Json } from '../database/schema';
+
+export type MessageRow = {
+    id: number;
+    createdAt: string;
+    channel: string;
+    direction: string;
+    sender: Json;
+    recipients: Json;
+    content: string;
+    threadId: string | null;
+    metadata: Json;
+    // Joined fields
+    sendAttempts?: MessageSendAttemptRow[];
+};
+
+export type MessageSendAttemptRow = {
+    id: number;
+    createdAt: string;
+    messageId: number;
+    providerName: string;
+    isSuccessful: boolean;
+    raw: Json;
+};
+
+export type MessagesListResponse = {
+    items: MessageRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+
+export type MessagesListParams = {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    channel?: string;
+    direction?: string;
+};
+
+/**
+ * Build query string for messages listing.
+ */
+function buildQuery(params: MessagesListParams): string {
+    const searchParams = new URLSearchParams();
+
+    if (params.page && params.page > 0) searchParams.set('page', String(params.page));
+    if (params.pageSize && params.pageSize > 0) searchParams.set('pageSize', String(params.pageSize));
+    if (params.search) searchParams.set('search', params.search);
+    if (params.channel) searchParams.set('channel', params.channel);
+    if (params.direction) searchParams.set('direction', params.direction);
+
+    const qs = searchParams.toString();
+    return qs ? `?${qs}` : '';
+}
+
+/**
+ * Fetch messages from the admin API.
+ */
+export async function $fetchMessages(params: MessagesListParams = {}): Promise<MessagesListResponse> {
+    const qs = buildQuery(params);
+    const response = await fetch(`/api/messages${qs}`, {
+        method: 'GET',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to load messages');
+    }
+
+    return (await response.json()) as MessagesListResponse;
+}

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

@@ -0,0 +1,25 @@
+import { capitalize } from '@promptbook/utils';
+
+/**
+ * Converts a filename like "cat-sitting-on-keyboard.png" to a prompt like "Cat sitting on keyboard"
+ *
+ * @param filename - The filename to convert
+ * @returns The normalized prompt
+ */
+export function filenameToPrompt(filename: string): string {
+    // Remove file extension
+    const withoutExtension = filename.replace(/\.[^/.]+$/, '');
+
+    // Replace dashes and underscores with spaces
+    const withSpaces = withoutExtension.replace(/[-_]/g, ' ');
+
+    // Capitalize each word
+    const words = withSpaces.split(' ');
+    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/apps/agents-server/src/utils/validateApiKey.ts

@@ -1,15 +1,6 @@
 import { createClient } from '@supabase/supabase-js';
 import { NextRequest } from 'next/server';
-import { SERVERS, SUPABASE_TABLE_PREFIX } from '../../config';
-
-// 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) => {
-            return word.toUpperCase();
-        })
-        .replace(/\s+/g, '');
-}
+import { $getTableName } from '../database/$getTableName';
 
 export type ApiKeyValidationResult = {
     isValid: boolean;
@@ -62,10 +53,14 @@ export async function validateApiKey(request: NextRequest): Promise<ApiKeyValida
         };
     }
 
+    /*
+    Note: [🐔] This code was commented out because results of it are unused
+    
     // Determine the table prefix based on the host
     const host = request.headers.get('host');
     let tablePrefix = SUPABASE_TABLE_PREFIX;
 
+    
     if (host && SERVERS && SERVERS.length > 0) {
         if (SERVERS.some((server) => server === host)) {
             let serverName = host;
@@ -74,6 +69,7 @@ export async function validateApiKey(request: NextRequest): Promise<ApiKeyValida
             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;
@@ -95,7 +91,7 @@ export async function validateApiKey(request: NextRequest): Promise<ApiKeyValida
         });
 
         const { data, error } = await supabase
-            .from(`${tablePrefix}ApiTokens`)
+            .from(await $getTableName(`ApiTokens`))
             .select('id, isRevoked')
             .eq('token', token)
             .single();