@promptbook/openai 0.61.0-9 → 0.62.0-0

package/README.md

@@ -43,7 +43,7 @@ import { OpenAiExecutionTools } from '@promptbook/openai';
 const collection = await createCollectionFromDirectory('./promptbook-collection');
 
 // ▶ Get single Pipeline
-const pipeline = await library.getPipelineByUrl(`https://promptbook.studio/my-collection/write-article.ptbk.md`);
+const pipeline = await collection.getPipelineByUrl(`https://promptbook.studio/my-collection/write-article.ptbk.md`);
 
 // ▶ Prepare tools
 const tools = {
@@ -71,6 +71,45 @@ const { isSuccessful, errors, outputParameters, executionReport } = result;
 console.info(outputParameters);
 ```
 
+## 🧙‍♂️ Connect to LLM providers automatically
+
+You can just use `createLlmToolsFromEnv` function to create LLM tools from environment variables like `OPENAI_API_KEY` and `ANTHROPIC_CLAUDE_API_KEY` automatically.
+
+```typescript
+import { createPipelineExecutor, createCollectionFromDirectory, assertsExecutionSuccessful } from '@promptbook/core';
+import { JavascriptExecutionTools } from '@promptbook/execute-javascript';
+import { createLlmToolsFromEnv } from '@promptbook/node';
+
+// ▶ Create whole pipeline collection
+const collection = await createCollectionFromDirectory('./promptbook-collection');
+
+// ▶ Get single Pipeline
+const pipeline = await collection.getPipelineByUrl(`https://promptbook.studio/my-collection/write-article.ptbk.md`);
+
+// ▶ Prepare multiple tools
+const tools = {
+    // Note: 🧙‍♂️ Just call `createLlmToolsFromEnv` to automatically connect to all configured providers
+    llm: createLlmToolsFromEnv(),
+    script: [new JavascriptExecutionTools()],
+};
+
+// ▶ Create executor - the function that will execute the Pipeline
+const pipelineExecutor = createPipelineExecutor({ pipeline, tools });
+
+// ▶ Prepare input parameters
+const inputParameters = { word: 'dog' };
+
+// 🚀▶ Execute the Pipeline
+const result = await pipelineExecutor(inputParameters);
+
+// ▶ Fail if the execution was not successful
+assertsExecutionSuccessful(result);
+
+// ▶ Handle the result
+const { isSuccessful, errors, outputParameters, executionReport } = result;
+console.info(outputParameters);
+```
+
 ## 💕 Usage of multiple LLM providers
 
 You can use multiple LLM providers in one Promptbook execution. The best model will be chosen automatically according to the prompt and the model's capabilities.
@@ -80,12 +119,14 @@ import { createPipelineExecutor, assertsExecutionSuccessful } from '@promptbook/
 import { createCollectionFromDirectory } from '@promptbook/node';
 import { JavascriptExecutionTools } from '@promptbook/execute-javascript';
 import { OpenAiExecutionTools } from '@promptbook/openai';
+import { AnthropicClaudeExecutionTools } from '@promptbook/anthropic-claude';
+import { AzureOpenAiExecutionTools } from '@promptbook/azure-openai';
 
 // ▶ Create whole pipeline collection
 const collection = await createCollectionFromDirectory('./promptbook-collection');
 
 // ▶ Get single Pipeline
-const pipeline = await library.getPipelineByUrl(`https://promptbook.studio/my-collection/write-article.ptbk.md`);
+const pipeline = await collection.getPipelineByUrl(`https://promptbook.studio/my-collection/write-article.ptbk.md`);
 
 // ▶ Prepare multiple tools
 const tools = {
@@ -186,7 +227,7 @@ File `write-website-content.ptbk.md`:
 > -   PROMPTBOOK VERSION 0.0.1
 > -   INPUT  PARAM `{rawTitle}` Automatically suggested a site name or empty text
 > -   INPUT  PARAM `{rawAssigment}` Automatically generated site entry from image recognition
-> -   OUTPUT PARAM `{content}` Web content
+> -   OUTPUT PARAM `{websiteContent}` Web content
 > -   OUTPUT PARAM `{keywords}` Keywords
 >
 > ## 👤 Specifying the assigment
@@ -345,7 +386,7 @@ File `write-website-content.ptbk.md`:
 > {contentBody}
 > ```
 >
-> `-> {content}`
+> `-> {websiteContent}`
 
 
 
@@ -385,7 +426,7 @@ flowchart LR
       templateCombineTheBeginning--"{contentBeginning}"-->templateCombineTheContent
       templateWriteTheContent--"{contentBody}"-->templateCombineTheContent
 
-      templateCombineTheContent--"{content}"-->output
+      templateCombineTheContent--"{websiteContent}"-->output
       output((Output)):::output
 
       classDef input color: grey;

package/esm/index.es.js

@@ -82,6 +82,18 @@ function __generator(thisArg, body) {
     }
 }
 
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
 function __read(o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -97,12 +109,22 @@ function __read(o, n) {
         finally { if (e) throw e.error; }
     }
     return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 }
 
 /**
  * Function computeUsage will create price per one token based on the string value found on openai page
  *
- * @private within the package, used only as internal helper for `OPENAI_MODELS`
+ * @private within the repository, used only as internal helper for `OPENAI_MODELS`
  */
 function computeUsage(value) {
     var _a = __read(value.split(' / '), 2), price = _a[0], tokens = _a[1];
@@ -456,6 +478,7 @@ var OPENAI_MODELS = [
  * @see /other/playground/playground.ts
  * TODO: [🍓] Make better
  * TODO: Change model titles to human eg: "gpt-4-turbo-2024-04-09" -> "GPT-4 Turbo (2024-04-09)"
+ * TODO: [🚸] Not all models are compatible with JSON mode, add this information here and use it
  */
 
 /**
@@ -495,6 +518,168 @@ function getCurrentIsoDate() {
     return new Date().toISOString();
 }
 
+/**
+ * @@@
+ *
+ * @returns The same object as the input, but deeply frozen
+ *
+ * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+ */
+function deepFreeze(objectValue) {
+    var e_1, _a;
+    var propertyNames = Object.getOwnPropertyNames(objectValue);
+    try {
+        for (var propertyNames_1 = __values(propertyNames), propertyNames_1_1 = propertyNames_1.next(); !propertyNames_1_1.done; propertyNames_1_1 = propertyNames_1.next()) {
+            var propertyName = propertyNames_1_1.value;
+            var value = objectValue[propertyName];
+            if (value && typeof value === 'object') {
+                deepFreeze(value);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (propertyNames_1_1 && !propertyNames_1_1.done && (_a = propertyNames_1.return)) _a.call(propertyNames_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return Object.freeze(objectValue);
+}
+/**
+ * TODO: [🔼] Export from `@promptbook/utils`
+ * TODO: [🧠] Is there a way how to meaningfully test this utility
+ */
+
+/**
+ * The maximum number of iterations for a loops
+ */
+var LOOP_LIMIT = 1000;
+/**
+ * Nonce which is used for replacing things in strings
+ */
+var REPLACING_NONCE = 'u$k42k%!V2zo34w7Fu#@QUHYPW';
+/**
+ * The names of the parameters that are reserved for special purposes
+ */
+deepFreeze([
+    'content',
+    'context',
+    'knowledge',
+    'samples',
+    'modelName',
+    'currentDate',
+    // <- TODO: Add more like 'date', 'modelName',...
+    // <- TODO: Add [emoji] + instructions ACRY when adding new reserved parameter
+]);
+/**
+ * @@@
+ */
+var RESERVED_PARAMETER_MISSING_VALUE = 'MISSING-' + REPLACING_NONCE;
+/**
+ * @@@
+ */
+var RESERVED_PARAMETER_RESTRICTED = 'RESTRICTED-' + REPLACING_NONCE;
+/*
+TODO: !!! Just testing false-negative detection of [🟡][🟢][🔵][⚪] leak
+*/
+// [🟡][🟢][🔵][⚪]
+/**
+ * TODO: [🔼] Export all to core
+ */
+
+/**
+ * This error type indicates that some limit was reached
+ */
+var LimitReachedError = /** @class */ (function (_super) {
+    __extends(LimitReachedError, _super);
+    function LimitReachedError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'LimitReachedError';
+        Object.setPrototypeOf(_this, LimitReachedError.prototype);
+        return _this;
+    }
+    return LimitReachedError;
+}(Error));
+
+/**
+ * Replaces parameters in template with values from parameters object
+ *
+ * @param template the template with parameters in {curly} braces
+ * @param parameters the object with parameters
+ * @returns the template with replaced parameters
+ * @throws {PipelineExecutionError} if parameter is not defined, not closed, or not opened
+ */
+function replaceParameters(template, parameters) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(Object.entries(parameters)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), parameterName = _d[0], parameterValue = _d[1];
+            if (parameterValue === RESERVED_PARAMETER_MISSING_VALUE) {
+                throw new UnexpectedError("Parameter {".concat(parameterName, "} has missing value"));
+            }
+            else if (parameterValue === RESERVED_PARAMETER_RESTRICTED) {
+                // TODO: [🍵]
+                throw new UnexpectedError("Parameter {".concat(parameterName, "} is restricted to use"));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var replacedTemplate = template;
+    var match;
+    var loopLimit = LOOP_LIMIT;
+    var _loop_1 = function () {
+        if (loopLimit-- < 0) {
+            throw new LimitReachedError('Loop limit reached during parameters replacement in `replaceParameters`');
+        }
+        var precol = match.groups.precol;
+        var parameterName = match.groups.parameterName;
+        if (parameterName === '') {
+            return "continue";
+        }
+        if (parameterName.indexOf('{') !== -1 || parameterName.indexOf('}') !== -1) {
+            throw new PipelineExecutionError('Parameter is already opened or not closed');
+        }
+        if (parameters[parameterName] === undefined) {
+            throw new PipelineExecutionError("Parameter {".concat(parameterName, "} is not defined"));
+        }
+        var parameterValue = parameters[parameterName];
+        if (parameterValue === undefined) {
+            throw new PipelineExecutionError("Parameter {".concat(parameterName, "} is not defined"));
+        }
+        parameterValue = parameterValue.toString();
+        if (parameterValue.includes('\n') && /^\s*\W{0,3}\s*$/.test(precol)) {
+            parameterValue = parameterValue
+                .split('\n')
+                .map(function (line, index) { return (index === 0 ? line : "".concat(precol).concat(line)); })
+                .join('\n');
+        }
+        replacedTemplate =
+            replacedTemplate.substring(0, match.index + precol.length) +
+                parameterValue +
+                replacedTemplate.substring(match.index + precol.length + parameterName.length + 2);
+    };
+    while ((match = /^(?<precol>.*){(?<parameterName>\w+)}(.*)/m /* <- Not global */
+        .exec(replacedTemplate))) {
+        _loop_1();
+    }
+    // [💫] Check if there are parameters that are not closed properly
+    if (/{\w+$/.test(replacedTemplate)) {
+        throw new PipelineExecutionError('Parameter is not closed');
+    }
+    // [💫] Check if there are parameters that are not opened properly
+    if (/^\w+}/.test(replacedTemplate)) {
+        throw new PipelineExecutionError('Parameter is not opened');
+    }
+    return replacedTemplate;
+}
+
 /**
  * Counts number of characters in the text
  */
@@ -914,35 +1099,46 @@ var OpenAiExecutionTools = /** @class */ (function () {
      */
     OpenAiExecutionTools.prototype.callChatModel = function (prompt) {
         return __awaiter(this, void 0, void 0, function () {
-            var content, modelRequirements, expectFormat, model, modelSettings, rawRequest, start, complete, rawResponse, resultContent, usage;
+            var content, parameters, modelRequirements, expectFormat, modelName, modelSettings, rawPromptContent, rawRequest, start, complete, rawResponse, resultContent, usage;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (this.options.isVerbose) {
                             console.info('💬 OpenAI callChatModel call', { prompt: prompt });
                         }
-                        content = prompt.content, modelRequirements = prompt.modelRequirements, expectFormat = prompt.expectFormat;
+                        content = prompt.content, parameters = prompt.parameters, modelRequirements = prompt.modelRequirements, expectFormat = prompt.expectFormat;
                         // TODO: [☂] Use here more modelRequirements
                         if (modelRequirements.modelVariant !== 'CHAT') {
                             throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
                         }
-                        model = modelRequirements.modelName || this.getDefaultChatModel().modelName;
+                        modelName = modelRequirements.modelName || this.getDefaultChatModel().modelName;
                         modelSettings = {
-                            model: model,
+                            model: modelName,
                             max_tokens: modelRequirements.maxTokens,
-                            //                                   <- TODO: Make some global max cap for maxTokens
+                            //                                   <- TODO: [🌾] Make some global max cap for maxTokens
+                            temperature: modelRequirements.temperature,
+                            // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
+                            // <- Note: [🧆]
                         };
                         if (expectFormat === 'JSON') {
                             modelSettings.response_format = {
                                 type: 'json_object',
                             };
                         }
-                        rawRequest = __assign(__assign({}, modelSettings), { messages: [
+                        rawPromptContent = replaceParameters(content, __assign(__assign({}, parameters), { modelName: modelName }));
+                        rawRequest = __assign(__assign({}, modelSettings), { messages: __spreadArray(__spreadArray([], __read((modelRequirements.systemMessage === undefined
+                                ? []
+                                : [
+                                    {
+                                        role: 'system',
+                                        content: modelRequirements.systemMessage,
+                                    },
+                                ])), false), [
                                 {
                                     role: 'user',
-                                    content: content,
+                                    content: rawPromptContent,
                                 },
-                            ], user: this.options.user });
+                            ], false), user: this.options.user });
                         start = getCurrentIsoDate();
                         if (this.options.isVerbose) {
                             console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
@@ -969,14 +1165,16 @@ var OpenAiExecutionTools = /** @class */ (function () {
                         }
                         return [2 /*return*/, {
                                 content: resultContent,
-                                modelName: rawResponse.model || model,
+                                modelName: rawResponse.model || modelName,
                                 timing: {
                                     start: start,
                                     complete: complete,
                                 },
                                 usage: usage,
+                                rawPromptContent: rawPromptContent,
+                                rawRequest: rawRequest,
                                 rawResponse: rawResponse,
-                                // <- [🤹‍♂️]
+                                // <- [🗯]
                             }];
                 }
             });
@@ -987,25 +1185,29 @@ var OpenAiExecutionTools = /** @class */ (function () {
      */
     OpenAiExecutionTools.prototype.callCompletionModel = function (prompt) {
         return __awaiter(this, void 0, void 0, function () {
-            var content, modelRequirements, model, modelSettings, rawRequest, start, complete, rawResponse, resultContent, usage;
+            var content, parameters, modelRequirements, modelName, modelSettings, rawPromptContent, rawRequest, start, complete, rawResponse, resultContent, usage;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (this.options.isVerbose) {
                             console.info('🖋 OpenAI callCompletionModel call', { prompt: prompt });
                         }
-                        content = prompt.content, modelRequirements = prompt.modelRequirements;
+                        content = prompt.content, parameters = prompt.parameters, modelRequirements = prompt.modelRequirements;
                         // TODO: [☂] Use here more modelRequirements
                         if (modelRequirements.modelVariant !== 'COMPLETION') {
                             throw new PipelineExecutionError('Use callCompletionModel only for COMPLETION variant');
                         }
-                        model = modelRequirements.modelName || this.getDefaultCompletionModel().modelName;
+                        modelName = modelRequirements.modelName || this.getDefaultCompletionModel().modelName;
                         modelSettings = {
-                            model: model,
-                            max_tokens: modelRequirements.maxTokens || 2000, // <- Note: 2000 is for lagacy reasons
-                            //                                                  <- TODO: Make some global max cap for maxTokens
+                            model: modelName,
+                            max_tokens: modelRequirements.maxTokens || 2000,
+                            //                                                  <- TODO: [🌾] Make some global max cap for maxTokens
+                            temperature: modelRequirements.temperature,
+                            // <- TODO: [🈁] Use `seed` here AND/OR use is `isDeterministic` for entire execution tools
+                            // <- Note: [🧆]
                         };
-                        rawRequest = __assign(__assign({}, modelSettings), { prompt: content, user: this.options.user });
+                        rawPromptContent = replaceParameters(content, __assign(__assign({}, parameters), { modelName: modelName }));
+                        rawRequest = __assign(__assign({}, modelSettings), { prompt: rawPromptContent, user: this.options.user });
                         start = getCurrentIsoDate();
                         if (this.options.isVerbose) {
                             console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
@@ -1029,14 +1231,16 @@ var OpenAiExecutionTools = /** @class */ (function () {
                         usage = computeOpenaiUsage(content, resultContent || '', rawResponse);
                         return [2 /*return*/, {
                                 content: resultContent,
-                                modelName: rawResponse.model || model,
+                                modelName: rawResponse.model || modelName,
                                 timing: {
                                     start: start,
                                     complete: complete,
                                 },
                                 usage: usage,
+                                rawPromptContent: rawPromptContent,
+                                rawRequest: rawRequest,
                                 rawResponse: rawResponse,
-                                // <- [🤹‍♂️]
+                                // <- [🗯]
                             }];
                 }
             });
@@ -1047,23 +1251,23 @@ var OpenAiExecutionTools = /** @class */ (function () {
      */
     OpenAiExecutionTools.prototype.callEmbeddingModel = function (prompt) {
         return __awaiter(this, void 0, void 0, function () {
-            var content, modelRequirements, model, rawRequest, start, complete, rawResponse, resultContent, usage;
+            var content, parameters, modelRequirements, modelName, rawPromptContent, rawRequest, start, complete, rawResponse, resultContent, usage;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (this.options.isVerbose) {
                             console.info('🖋 OpenAI embedding call', { prompt: prompt });
                         }
-                        content = prompt.content, modelRequirements = prompt.modelRequirements;
+                        content = prompt.content, parameters = prompt.parameters, modelRequirements = prompt.modelRequirements;
                         // TODO: [☂] Use here more modelRequirements
                         if (modelRequirements.modelVariant !== 'EMBEDDING') {
                             throw new PipelineExecutionError('Use embed only for EMBEDDING variant');
                         }
-                        model = modelRequirements.modelName || this.getDefaultEmbeddingModel().modelName;
+                        modelName = modelRequirements.modelName || this.getDefaultEmbeddingModel().modelName;
+                        rawPromptContent = replaceParameters(content, __assign(__assign({}, parameters), { modelName: modelName }));
                         rawRequest = {
-                            input: content,
-                            model: model,
-                            // TODO: !!!! Test model 3 and dimensions
+                            input: rawPromptContent,
+                            model: modelName,
                         };
                         start = getCurrentIsoDate();
                         if (this.options.isVerbose) {
@@ -1084,14 +1288,16 @@ var OpenAiExecutionTools = /** @class */ (function () {
                         usage = computeOpenaiUsage(content, '', rawResponse);
                         return [2 /*return*/, {
                                 content: resultContent,
-                                modelName: rawResponse.model || model,
+                                modelName: rawResponse.model || modelName,
                                 timing: {
                                     start: start,
                                     complete: complete,
                                 },
                                 usage: usage,
+                                rawPromptContent: rawPromptContent,
+                                rawRequest: rawRequest,
                                 rawResponse: rawResponse,
-                                // <- [🤹‍♂️]
+                                // <- [🗯]
                             }];
                 }
             });
@@ -1108,9 +1314,9 @@ var OpenAiExecutionTools = /** @class */ (function () {
         });
         if (model === undefined) {
             throw new UnexpectedError(spaceTrim$1(function (block) {
-                return "\n                            Cannot find model in OpenAI models with name ".concat(defaultModelName, " which should be used as default.\n\n                            Available models:\n                            ").concat(block(OPENAI_MODELS.map(function (_a) {
+                return "\n                            Cannot find model in OpenAI models with name \"".concat(defaultModelName, "\" which should be used as default.\n\n                            Available models:\n                            ").concat(block(OPENAI_MODELS.map(function (_a) {
                     var modelName = _a.modelName;
-                    return "- ".concat(modelName);
+                    return "- \"".concat(modelName, "\"");
                 }).join('\n')), "\n\n                        ");
             }));
         }
@@ -1154,12 +1360,13 @@ var OpenAiExecutionTools = /** @class */ (function () {
  * TODO: [🧠][🧙‍♂️] Maybe there can be some wizzard for thoose who want to use just OpenAI
  * TODO: Maybe Create some common util for callChatModel and callCompletionModel
  * TODO: Maybe make custom OpenaiError
+ * TODO: [🧠][🈁] Maybe use `isDeterministic` from options
  */
 
 /**
  * The version of the Promptbook library
  */
-var PROMPTBOOK_VERSION = '0.61.0-8';
+var PROMPTBOOK_VERSION = '0.61.0';
 // TODO: !!!! List here all the versions and annotate + put into script
 
 export { OPENAI_MODELS, OpenAiExecutionTools, PROMPTBOOK_VERSION };