@promptbook/cli 0.103.0-53 → 0.103.0-55

package/apps/agents-server/src/database/schema.ts

@@ -242,6 +242,57 @@ export type AgentsServerDatabase = {
                 };
                 Relationships: [];
             };
+            LlmCache: {
+                Row: {
+                    id: number;
+                    createdAt: string;
+                    updatedAt: string;
+                    hash: string;
+                    value: Json;
+                };
+                Insert: {
+                    id?: number;
+                    createdAt?: string;
+                    updatedAt?: string;
+                    hash: string;
+                    value: Json;
+                };
+                Update: {
+                    id?: number;
+                    createdAt?: string;
+                    updatedAt?: string;
+                    hash?: string;
+                    value?: Json;
+                };
+                Relationships: [];
+            };
+            ApiTokens: {
+                Row: {
+                    id: number;
+                    createdAt: string;
+                    updatedAt: string;
+                    token: string;
+                    note: string | null;
+                    isRevoked: boolean;
+                };
+                Insert: {
+                    id?: number;
+                    createdAt?: string;
+                    updatedAt?: string;
+                    token: string;
+                    note?: string | null;
+                    isRevoked?: boolean;
+                };
+                Update: {
+                    id?: number;
+                    createdAt?: string;
+                    updatedAt?: string;
+                    token?: string;
+                    note?: string | null;
+                    isRevoked?: boolean;
+                };
+                Relationships: [];
+            };
         };
         Views: Record<string, never>;
         Functions: Record<string, never>;

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

@@ -75,9 +75,57 @@ export async function middleware(req: NextRequest) {
     const allowedIps =
         allowedIpsMetadata !== null && allowedIpsMetadata !== undefined ? allowedIpsMetadata : allowedIpsEnv;
 
+    let isValidToken = false;
+    const authHeader = req.headers.get('authorization');
+
+    if (authHeader && authHeader.startsWith('Bearer ')) {
+        const token = authHeader.split(' ')[1];
+
+        if (token.startsWith('ptbk_')) {
+            const host = req.headers.get('host');
+            let tablePrefix = SUPABASE_TABLE_PREFIX;
+
+            if (host && SERVERS && SERVERS.length > 0) {
+                if (SERVERS.some((server) => server === host)) {
+                    let serverName = host;
+                    serverName = serverName.replace(/\.ptbk\.io$/, '');
+                    serverName = normalizeTo_PascalCase(serverName);
+                    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;
+
+            if (supabaseUrl && supabaseKey) {
+                try {
+                    const supabase = createClient(supabaseUrl, supabaseKey, {
+                        auth: {
+                            persistSession: false,
+                            autoRefreshToken: false,
+                        },
+                    });
+
+                    const { data } = await supabase
+                        .from(`${tablePrefix}ApiTokens`)
+                        .select('id')
+                        .eq('token', token)
+                        .eq('isRevoked', false)
+                        .single();
+
+                    if (data) {
+                        isValidToken = true;
+                    }
+                } catch (error) {
+                    console.error('Error validating token in middleware:', error);
+                }
+            }
+        }
+    }
+
     const isIpAllowedResult = isIpAllowed(ip, allowedIps);
     const isLoggedIn = req.cookies.has('sessionToken');
-    const isAccessRestricted = !isIpAllowedResult && !isLoggedIn;
+    const isAccessRestricted = !isIpAllowedResult && !isLoggedIn && !isValidToken;
 
     // Handle OPTIONS (preflight) requests globally
     if (req.method === 'OPTIONS') {
@@ -86,7 +134,7 @@ export async function middleware(req: NextRequest) {
             headers: {
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-                'Access-Control-Allow-Headers': 'Content-Type',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
             },
         });
     }

package/apps/agents-server/src/tools/$provideCdnForServer.ts

@@ -1,4 +1,4 @@
-import { DigitalOceanSpaces } from '../utils/cdn/classes/DigitalOceanSpaces';
+import { VercelBlobStorage } from '../utils/cdn/classes/VercelBlobStorage';
 import { IIFilesStorageWithCdn } from '../utils/cdn/interfaces/IFilesStorage';
 
 /**
@@ -13,14 +13,10 @@ let cdn: IIFilesStorageWithCdn | null = null;
  */
 export function $provideCdnForServer(): IIFilesStorageWithCdn {
     if (!cdn) {
-        cdn = new DigitalOceanSpaces({
-            bucket: process.env.CDN_BUCKET!,
+        cdn = new VercelBlobStorage({
+            token: process.env.BLOB_READ_WRITE_TOKEN!,
             pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
-            endpoint: process.env.CDN_ENDPOINT!,
-            accessKeyId: process.env.CDN_ACCESS_KEY_ID!,
-            secretAccessKey: process.env.CDN_SECRET_ACCESS_KEY!,
             cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
-            gzip: true,
         });
     }
 

package/apps/agents-server/src/tools/$provideExecutionToolsForServer.ts

@@ -1,6 +1,7 @@
 'use server';
 
 import {
+    cacheLlmTools,
     _AnthropicClaudeMetadataRegistration,
     _AzureOpenAiMetadataRegistration,
     _BoilerplateScraperMetadataRegistration,
@@ -26,6 +27,7 @@ import { $provideFilesystemForNode } from '../../../../src/scrapers/_common/regi
 import { $provideScrapersForNode } from '../../../../src/scrapers/_common/register/$provideScrapersForNode';
 import { $provideScriptingForNode } from '../../../../src/scrapers/_common/register/$provideScriptingForNode';
 import { $sideEffect } from '../../../../src/utils/organization/$sideEffect';
+import { SupabaseCacheStorage } from '../utils/cache/SupabaseCacheStorage';
 
 $sideEffect(
     _AnthropicClaudeMetadataRegistration,
@@ -90,10 +92,17 @@ export async function $provideExecutionToolsForServer(): Promise<ExecutionTools>
         isCacheReloaded,
     }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
     const fs = await $provideFilesystemForNode(prepareAndScrapeOptions);
-    const { /* [0] strategy,*/ llm } = await $provideLlmToolsForCli({
+    const { /* [0] strategy,*/ llm: llmUncached } = await $provideLlmToolsForCli({
         cliOptions,
         ...prepareAndScrapeOptions,
     });
+
+    const llm = cacheLlmTools(llmUncached, {
+        storage: new SupabaseCacheStorage(),
+        isVerbose,
+        isCacheReloaded,
+    });
+
     const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
 
     executionTools = {

package/apps/agents-server/src/utils/cache/SupabaseCacheStorage.ts

@@ -0,0 +1,55 @@
+import { TODO_any } from '@promptbook-local/types';
+import { $getTableName } from '../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
+import { Json } from '../../database/schema';
+
+/**
+ * Storage for LLM cache using Supabase
+ */
+export class SupabaseCacheStorage {
+    // implements PromptbookStorage<TODO_any>
+
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
+     */
+    public async getItem(key: string): Promise<TODO_any | null> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        const { data } = await supabase.from(tableName).select('value').eq('hash', key).maybeSingle();
+
+        if (!data) {
+            return null;
+        }
+
+        return data.value;
+    }
+
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    public async setItem(key: string, value: TODO_any): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).upsert(
+            {
+                hash: key,
+                value: value as Json,
+            },
+            {
+                onConflict: 'hash',
+            },
+        );
+    }
+
+    /**
+     * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists
+     */
+    public async removeItem(key: string): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).delete().eq('hash', key);
+    }
+}

package/apps/agents-server/src/utils/cdn/classes/VercelBlobStorage.ts

@@ -0,0 +1,63 @@
+import { del, put } from '@vercel/blob';
+import { validateMimeType } from '../../validators/validateMimeType';
+import type { IFile, IIFilesStorageWithCdn } from '../interfaces/IFilesStorage';
+
+type IVercelBlobStorageConfig = {
+    readonly token: string;
+    readonly cdnPublicUrl: URL;
+    readonly pathPrefix?: string;
+    // Note: Vercel Blob automatically handles compression/serving
+};
+
+export class VercelBlobStorage implements IIFilesStorageWithCdn {
+    public get cdnPublicUrl() {
+        return this.config.cdnPublicUrl;
+    }
+
+    public constructor(private readonly config: IVercelBlobStorageConfig) {}
+
+    public getItemUrl(key: string): URL {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+        return new URL(path, this.cdnPublicUrl);
+    }
+
+    public async getItem(key: string): Promise<IFile | null> {
+        const url = this.getItemUrl(key);
+
+        const response = await fetch(url);
+
+        if (response.status === 404) {
+            return null;
+        }
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch blob from ${url}: ${response.statusText}`);
+        }
+
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const contentType = response.headers.get('content-type') || 'application/octet-stream';
+
+        return {
+            type: validateMimeType(contentType),
+            data: buffer,
+        };
+    }
+
+    public async removeItem(key: string): Promise<void> {
+        const url = this.getItemUrl(key).toString();
+        await del(url, { token: this.config.token });
+    }
+
+    public async setItem(key: string, file: IFile): Promise<void> {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+        
+        await put(path, file.data, {
+            access: 'public',
+            addRandomSuffix: false,
+            contentType: file.type,
+            token: this.config.token,
+            // Note: We rely on Vercel Blob for compression
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Converts an array of objects to a CSV string
+ */
+export function convertToCsv(data: Array<Record<string, unknown>>): string {
+    if (data.length === 0) {
+        return '';
+    }
+
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+
+    for (const row of data) {
+        const values = headers.map((header) => {
+            let value = row[header];
+
+            if (value === null || value === undefined) {
+                value = '';
+            } else if (typeof value === 'object') {
+                value = JSON.stringify(value);
+            } else {
+                value = String(value);
+            }
+
+            const escaped = (value as string).replace(/"/g, '""');
+            return `"${escaped}"`;
+        });
+        csvRows.push(values.join(','));
+    }
+
+    return csvRows.join('\n');
+}

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

@@ -0,0 +1,183 @@
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { $provideExecutionToolsForServer } from '@/src/tools/$provideExecutionToolsForServer';
+import { Agent } from '@promptbook-local/core';
+import { ChatMessage, ChatPromptResult, Prompt, TODO_any } from '@promptbook-local/types';
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function handleChatCompletion(
+    request: NextRequest,
+    params: { agentName: string },
+    title: string = 'API Chat Completion'
+) {
+    const { agentName } = params;
+
+    // Note: Authentication is handled by middleware
+    // If we are here, the request is either authenticated or public access is allowed (but middleware blocks it if not)
+
+    try {
+        const body = await request.json();
+        const { messages, stream, model } = body;
+
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            return NextResponse.json(
+                {
+                    error: {
+                        message: 'Messages array is required and cannot be empty.',
+                        type: 'invalid_request_error',
+                    },
+                },
+                { status: 400 },
+            );
+        }
+
+        const collection = await $provideAgentCollectionForServer();
+        let agentSource;
+        try {
+            agentSource = await collection.getAgentSource(agentName);
+        } catch (error) {
+            return NextResponse.json(
+                { error: { message: `Agent '${agentName}' not found.`, type: 'invalid_request_error' } },
+                { status: 404 },
+            );
+        }
+
+        if (!agentSource) {
+            return NextResponse.json(
+                { error: { message: `Agent '${agentName}' not found.`, type: 'invalid_request_error' } },
+                { status: 404 },
+            );
+        }
+
+        const executionTools = await $provideExecutionToolsForServer();
+        const agent = new Agent({
+            agentSource,
+            executionTools,
+            isVerbose: true, // or false
+        });
+
+        // Prepare thread and content
+        const lastMessage = messages[messages.length - 1];
+        const previousMessages = messages.slice(0, -1);
+
+        const thread: ChatMessage[] = previousMessages.map((msg: TODO_any, index: number) => ({
+            id: `msg-${index}`, // Placeholder ID
+            from: 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
+        }));
+
+        const prompt: Prompt = {
+            title,
+            content: lastMessage.content,
+            modelRequirements: {
+                modelVariant: 'CHAT',
+                // We could pass 'model' from body if we wanted to enforce it, but Agent usually has its own config
+            },
+            parameters: {},
+            thread,
+        } as Prompt;
+        // Note: Casting as Prompt because the type definition might require properties we don't strictly use or that are optional but TS complains
+
+        if (stream) {
+            const encoder = new TextEncoder();
+            const readableStream = new ReadableStream({
+                async start(controller) {
+                    const runId = `chatcmpl-${Math.random().toString(36).substring(2, 15)}`;
+                    const created = Math.floor(Date.now() / 1000);
+
+                    let previousContent = '';
+
+                    try {
+                        await agent.callChatModelStream(prompt, (chunk: ChatPromptResult) => {
+                            const fullContent = chunk.content;
+                            const deltaContent = fullContent.substring(previousContent.length);
+                            previousContent = fullContent;
+
+                            if (deltaContent) {
+                                const chunkData = {
+                                    id: runId,
+                                    object: 'chat.completion.chunk',
+                                    created,
+                                    model: model || 'promptbook-agent',
+                                    choices: [
+                                        {
+                                            index: 0,
+                                            delta: {
+                                                content: deltaContent,
+                                            },
+                                            finish_reason: null,
+                                        },
+                                    ],
+                                };
+                                controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunkData)}\n\n`));
+                            }
+                        });
+
+                        const doneChunkData = {
+                            id: runId,
+                            object: 'chat.completion.chunk',
+                            created,
+                            model: model || 'promptbook-agent',
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: {},
+                                    finish_reason: 'stop',
+                                },
+                            ],
+                        };
+                        controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunkData)}\n\n`));
+                        controller.enqueue(encoder.encode('[DONE]'));
+                    } catch (error) {
+                        console.error('Error during streaming:', error);
+                        // OpenAI stream doesn't usually send error JSON in stream, just closes or sends error text?
+                        // But we should try to close gracefully or error.
+                        controller.error(error);
+                    }
+                    controller.close();
+                },
+            });
+
+            return new Response(readableStream, {
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                },
+            });
+        } else {
+            const result = await agent.callChatModel(prompt);
+
+            return NextResponse.json({
+                id: `chatcmpl-${Math.random().toString(36).substring(2, 15)}`,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: model || 'promptbook-agent',
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: result.content,
+                        },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: result.usage?.input?.tokensCount?.value || 0,
+                    completion_tokens: result.usage?.output?.tokensCount?.value || 0,
+                    total_tokens:
+                        (result.usage?.input?.tokensCount?.value || 0) +
+                        (result.usage?.output?.tokensCount?.value || 0),
+                },
+            });
+        }
+    } catch (error) {
+        console.error(`Error in ${title} handler:`, error);
+        return NextResponse.json(
+            { error: { message: (error as Error).message || 'Internal Server Error', type: 'server_error' } },
+            { status: 500 },
+        );
+    }
+}

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

@@ -0,0 +1,93 @@
+import { createAgentModelRequirements } from '@promptbook-local/core';
+import type { AgentCollection } from '@promptbook-local/types';
+type string_book = string & { readonly __type: 'book' };
+
+/**
+ * Resolves agent source with inheritance (FROM commitment)
+ *
+ * It recursively fetches the parent agent source and merges it with the current source.
+ *
+ * @param agentSource The initial agent source
+ * @param collection Optional agent collection to resolve local agents efficiently
+ * @returns The resolved agent source with inheritance applied
+ */
+export async function resolveInheritedAgentSource(
+    agentSource: string_book,
+    collection?: AgentCollection,
+): Promise<string_book> {
+    // Check if the source has FROM commitment
+    // We use createAgentModelRequirements to parse commitments
+    // Note: We don't provide tools/models here as we only care about parsing commitments
+    const requirements = await createAgentModelRequirements(agentSource);
+
+    if (!requirements.parentAgentUrl) {
+        return agentSource;
+    }
+
+    const parentUrl = requirements.parentAgentUrl;
+    let parentSource: string_book;
+
+    try {
+        // 1. Try to resolve locally using collection if possible
+        // This is an optimization for internal agents
+        // We assume the URL might be relative or contain the agent name, or we just check if it's a full URL
+        // If it's a full URL, we need to check if it matches our server, but without knowing our server URL it's hard.
+        // So we might need to parse the URL to extract agent name if it matches expected pattern.
+        // For now, let's rely on fetch for external and check collection if it looks like a local reference (though FROM expects URL)
+
+        // If the URL is valid, we try to fetch it
+        // TODO: Handle authentication/tokens for private agents if needed
+        const response = await fetch(parentUrl);
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch parent agent from ${parentUrl}: ${response.status} ${response.statusText}`);
+        }
+
+        // We assume the response is the agent source text
+        // TODO: Handle content negotiation or JSON responses if the server returns JSON
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+             const data = await response.json();
+             // Assume some structure or that the API returns source in a property
+             // For Agents Server API modelRequirements/route.ts returns AgentModelRequirements, not source.
+             // If we point to a raw source endpoint, it returns text.
+             // If we point to the agent page, it returns HTML.
+             // We need a standard way to get source.
+                 // For now, let's assume the URL points to the source or an API returning source.
+             if (typeof data === 'string') {
+                 parentSource = data as string_book;
+             } else if (data.source) {
+                 parentSource = data.source as string_book;
+             } else {
+                 // Fallback or error
+                 console.warn(`Received JSON from ${parentUrl} but couldn't determine source property. Using text.`);
+                 // Re-fetch as text? Or assume body text was read? response.json() consumes body.
+                 // So we might have failed here.
+                 throw new Error(`Received JSON from ${parentUrl} but structure is unknown.`);
+             }
+        } else {
+            parentSource = (await response.text()) as string_book;
+        }
+
+    } catch (error) {
+        console.warn(`Failed to resolve parent agent ${parentUrl}`, error);
+        // If we fail to resolve parent, we return the original source (maybe with a warning or error commitment?)
+        // Or we could throw to fail the build.
+        // For robustness, let's append a warning comment
+        return `${agentSource}\n\n# Warning: Failed to inherit from ${parentUrl}: ${error}` as string_book;
+    }
+
+    // Recursively resolve the parent source
+    const effectiveParentSource = await resolveInheritedAgentSource(parentSource, collection);
+
+    // Strip the FROM commitment from the child source to avoid infinite recursion or re-processing
+    // We can filter lines starting with FROM
+    const childSourceLines = agentSource.split('\n');
+    const filteredChildSource = childSourceLines
+        .filter((line: string) => !line.trim().startsWith('FROM ')) // Simple string check, ideally should use parser location
+        .join('\n');
+
+    // Append child source to parent source
+    // "appends the RULE commitment to its source" -> Parent + Child
+    return `${effectiveParentSource}\n\n${filteredChildSource}` as string_book;
+}