@promptbook/cli 0.103.0-67 → 0.103.0-68

package/apps/agents-server/src/components/_utils/generateMetaTxt.ts

@@ -0,0 +1,28 @@
+// Utility to generate content for robots.txt, security.txt, and humans.txt [DRY]
+
+import { NEXT_PUBLIC_SITE_URL } from '@/config';
+
+// Get base URL from environment or config
+const baseUrl = NEXT_PUBLIC_SITE_URL?.href || process.env.PUBLIC_URL || 'https://ptbk.io';
+
+export function generateRobotsTxt(): string {
+    return ['User-agent: *', `Sitemap: ${baseUrl}sitemap.xml`, ''].join('\n');
+}
+
+export function generateSecurityTxt(): string {
+    // See https://securitytxt.org/ for more fields
+    return [
+        `Contact: mailto:security@ptbk.io`,
+        `Expires: ${new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString().split('T')[0]}`,
+        `Canonical: ${baseUrl}security.txt`,
+        '',
+    ].join('\n');
+}
+
+export function generateHumansTxt(): string {
+    return ['/* TEAM */', 'Developer: Promptbook Team', `Site: https://ptbk.io`, `Instance: ${baseUrl}`].join('\n');
+}
+
+/**
+ * TODO: Use `spaceTrim`
+ */

package/apps/agents-server/src/components/_utils/headlessParam.tsx

@@ -0,0 +1,36 @@
+// Utility to append ?headless param if present in current URL
+import { usePathname, useSearchParams } from 'next/navigation';
+import Link, { LinkProps } from 'next/link';
+import { useMemo } from 'react';
+
+// Returns true if ?headless is present in current search params
+export function useIsHeadless() {
+    const searchParams = useSearchParams();
+    return searchParams.has('headless');
+}
+
+// Appends ?headless to a given href if needed
+export function appendHeadlessParam(href: string, isHeadless: boolean): string {
+    if (!isHeadless) return href;
+    if (href.includes('headless')) return href;
+    const hasQuery = href.includes('?');
+    return hasQuery ? `${href}&headless` : `${href}?headless`;
+}
+
+// Custom Link that preserves headless param
+export function HeadlessLink({ href, children, ...rest }: LinkProps & { children: React.ReactNode } & React.AnchorHTMLAttributes<HTMLAnchorElement>) {
+    const isHeadless = useIsHeadless();
+    const finalHref = useMemo(() => appendHeadlessParam(String(href), isHeadless), [href, isHeadless]);
+    return (
+        <Link href={finalHref} {...rest}>
+            {children}
+        </Link>
+    );
+}
+
+import { useRouter } from "next/navigation";
+
+// Helper for router.push
+export function pushWithHeadless(router: ReturnType<typeof useRouter>, href: string, isHeadless: boolean) {
+    router.push(appendHeadlessParam(href, isHeadless));
+}

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

@@ -191,12 +191,16 @@ export async function middleware(req: NextRequest) {
             'api',
             'admin',
             'docs',
-            'manifest.webmanifest',
-            'sw.js',
             'test',
             'embed',
             '_next',
+            'manifest.webmanifest',
+            'sw.js',
             'favicon.ico',
+            'sitemap.xml',
+            'robots.txt',
+            'security.txt',
+            'humans.txt',
         ].includes(potentialAgentName) &&
         !potentialAgentName.startsWith('.') &&
         // Note: Other static files are excluded by the matcher configuration below

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.103.0-67';
+const PROMPTBOOK_ENGINE_VERSION = '0.103.0-68';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -10936,7 +10936,7 @@ const jokerCommandParser = {
  * @see {@link ModelVariant}
  * @public exported from `@promptbook/core`
  */
-const MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
+const MODEL_VARIANTS = ['COMPLETION', 'CHAT', 'IMAGE_GENERATION', 'EMBEDDING' /* <- TODO [🏳] */ /* <- [🤖] */];
 
 /**
  * Parses the model command
@@ -17575,12 +17575,18 @@ const OPENAI_MODELS = exportJson({
             },
         },
         /**/
-        /*/
-          {
-              modelTitle: 'dall-e-3',
-              modelName: 'dall-e-3',
-          },
-          /**/
+        /**/
+        {
+            modelVariant: 'IMAGE_GENERATION',
+            modelTitle: 'dall-e-3',
+            modelName: 'dall-e-3',
+            modelDescription: 'DALL·E 3 is the latest version of the DALL·E art generation model. It understands significantly more nuance and detail than our previous systems, allowing you to easily translate your ideas into exceptionally accurate images.',
+            pricing: {
+                prompt: 0,
+                output: 0.04,
+            },
+        },
+        /**/
         /*/
           {
               modelTitle: 'whisper-1',
@@ -17599,12 +17605,18 @@ const OPENAI_MODELS = exportJson({
             },
         },
         /**/
-        /*/
-      {
-          modelTitle: 'dall-e-2',
-          modelName: 'dall-e-2',
-      },
-      /**/
+        /**/
+        {
+            modelVariant: 'IMAGE_GENERATION',
+            modelTitle: 'dall-e-2',
+            modelName: 'dall-e-2',
+            modelDescription: 'DALL·E 2 is an AI system that can create realistic images and art from a description in natural language.',
+            pricing: {
+                prompt: 0,
+                output: 0.02,
+            },
+        },
+        /**/
         /**/
         {
             modelVariant: 'CHAT',
@@ -19819,6 +19831,151 @@ class OpenAiCompatibleExecutionTools {
             return this.callEmbeddingModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
         }
     }
+    /**
+     * Calls OpenAI compatible API to use a image generation model
+     */
+    async callImageGenerationModel(prompt) {
+        // Deep clone prompt and modelRequirements to avoid mutation across calls
+        const clonedPrompt = JSON.parse(JSON.stringify(prompt));
+        const retriedUnsupportedParameters = new Set();
+        return this.callImageGenerationModelWithRetry(clonedPrompt, clonedPrompt.modelRequirements, [], retriedUnsupportedParameters);
+    }
+    /**
+     * Internal method that handles parameter retry for image generation model calls
+     */
+    async callImageGenerationModelWithRetry(prompt, currentModelRequirements, attemptStack = [], retriedUnsupportedParameters = new Set()) {
+        var _a, _b;
+        if (this.options.isVerbose) {
+            console.info(`🎨 ${this.title} callImageGenerationModel call`, { prompt, currentModelRequirements });
+        }
+        const { content, parameters } = prompt;
+        const client = await this.getClient();
+        // TODO: [☂] Use here more modelRequirements
+        if (currentModelRequirements.modelVariant !== 'IMAGE_GENERATION') {
+            throw new PipelineExecutionError('Use callImageGenerationModel only for IMAGE_GENERATION variant');
+        }
+        const modelName = currentModelRequirements.modelName || this.getDefaultImageGenerationModel().modelName;
+        const modelSettings = {
+            model: modelName,
+            // size: currentModelRequirements.size,
+            // quality: currentModelRequirements.quality,
+            // style: currentModelRequirements.style,
+        };
+        const rawPromptContent = templateParameters(content, { ...parameters, modelName });
+        const rawRequest = {
+            ...modelSettings,
+            prompt: rawPromptContent,
+            user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
+            response_format: 'url', // TODO: [🧠] Maybe allow b64_json
+        };
+        const start = $getCurrentDate();
+        if (this.options.isVerbose) {
+            console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
+        }
+        try {
+            const rawResponse = await this.limiter
+                .schedule(() => this.makeRequestWithNetworkRetry(() => client.images.generate(rawRequest)))
+                .catch((error) => {
+                assertsError(error);
+                if (this.options.isVerbose) {
+                    console.info(colors.bgRed('error'), error);
+                }
+                throw error;
+            });
+            if (this.options.isVerbose) {
+                console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
+            }
+            const complete = $getCurrentDate();
+            if (!rawResponse.data[0]) {
+                throw new PipelineExecutionError(`No choises from ${this.title}`);
+            }
+            if (rawResponse.data.length > 1) {
+                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
+            }
+            const resultContent = rawResponse.data[0].url;
+            const modelInfo = this.HARDCODED_MODELS.find((model) => model.modelName === modelName);
+            const price = ((_b = modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.pricing) === null || _b === void 0 ? void 0 : _b.output) ? uncertainNumber(modelInfo.pricing.output) : uncertainNumber();
+            return exportJson({
+                name: 'promptResult',
+                message: `Result of \`OpenAiCompatibleExecutionTools.callImageGenerationModel\``,
+                order: [],
+                value: {
+                    content: resultContent,
+                    modelName: modelName,
+                    timing: {
+                        start,
+                        complete,
+                    },
+                    usage: {
+                        price,
+                        input: {
+                            tokensCount: uncertainNumber(0),
+                            ...computeUsageCounts(rawPromptContent),
+                        },
+                        output: {
+                            tokensCount: uncertainNumber(0),
+                            ...computeUsageCounts(''),
+                        },
+                    },
+                    rawPromptContent,
+                    rawRequest,
+                    rawResponse,
+                },
+            });
+        }
+        catch (error) {
+            assertsError(error);
+            if (!isUnsupportedParameterError(error)) {
+                if (attemptStack.length > 0) {
+                    throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                        attemptStack
+                            .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                            (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                            `, Error: ${a.errorMessage}` +
+                            (a.stripped ? ' (stripped and retried)' : ''))
+                            .join('\n') +
+                        `\nFinal error: ${error.message}`);
+                }
+                throw error;
+            }
+            const unsupportedParameter = parseUnsupportedParameterError(error.message);
+            if (!unsupportedParameter) {
+                if (this.options.isVerbose) {
+                    console.warn(colors.bgYellow('Warning'), 'Could not parse unsupported parameter from error:', error.message);
+                }
+                throw error;
+            }
+            const retryKey = `${modelName}-${unsupportedParameter}`;
+            if (retriedUnsupportedParameters.has(retryKey)) {
+                attemptStack.push({
+                    modelName,
+                    unsupportedParameter,
+                    errorMessage: error.message,
+                    stripped: true,
+                });
+                throw new PipelineExecutionError(`All attempts failed. Attempt history:\n` +
+                    attemptStack
+                        .map((a, i) => `  ${i + 1}. Model: ${a.modelName}` +
+                        (a.unsupportedParameter ? `, Stripped: ${a.unsupportedParameter}` : '') +
+                        `, Error: ${a.errorMessage}` +
+                        (a.stripped ? ' (stripped and retried)' : ''))
+                        .join('\n') +
+                    `\nFinal error: ${error.message}`);
+            }
+            retriedUnsupportedParameters.add(retryKey);
+            if (this.options.isVerbose) {
+                console.warn(colors.bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
+            }
+            attemptStack.push({
+                modelName,
+                unsupportedParameter,
+                errorMessage: error.message,
+                stripped: true,
+            });
+            const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
+            return this.callImageGenerationModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
+        }
+    }
     // <- Note: [🤖] callXxxModel
     /**
      * Get the model that should be used as default
@@ -20242,6 +20399,13 @@ class OllamaExecutionTools extends OpenAiCompatibleExecutionTools {
         return this.getDefaultModel('text-embedding-3-large'); // <- TODO: [🧠] Pick the best default model
         // <- TODO: [🛄]
     }
+    /**
+     * Default model for image generation variant.
+     */
+    getDefaultImageGenerationModel() {
+        return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
+        // <- TODO: [🛄]
+    }
 }
 /**
  * TODO: [🛄] Some way how to re-wrap the errors from `OpenAiCompatibleExecutionTools`
@@ -20477,6 +20641,12 @@ class OpenAiExecutionTools extends OpenAiCompatibleExecutionTools {
     getDefaultEmbeddingModel() {
         return this.getDefaultModel('text-embedding-3-large');
     }
+    /**
+     * Default model for image generation variant.
+     */
+    getDefaultImageGenerationModel() {
+        return this.getDefaultModel('dall-e-3');
+    }
 }
 
 /**
@@ -21047,6 +21217,13 @@ class HardcodedOpenAiCompatibleExecutionTools extends OpenAiCompatibleExecutionT
     getDefaultEmbeddingModel() {
         throw new PipelineExecutionError(`${this.title} does not support EMBEDDING model variant`);
     }
+    /**
+     * Default model for image generation variant.
+     */
+    getDefaultImageGenerationModel() {
+        return this.getDefaultModel('!!!'); // <- TODO: [🧠] Pick the best default model
+        // <- TODO: [🛄]
+    }
 }
 /**
  * TODO: [🦺] Is there some way how to put `packageName` and `className` on top and function definition on bottom?