@promptbook/openai 0.61.0-9 → 0.62.0-0

package/esm/typings/src/utils/validators/url/isValidUrl.d.ts

@@ -1,4 +1,5 @@
 import type { string_url } from '../../../types/typeAliases';
+import type { really_unknown } from '../../organization/really_unknown';
 /**
  * Tests if given string is valid URL.
  *
@@ -7,4 +8,4 @@ import type { string_url } from '../../../types/typeAliases';
  * - `isValidUrl` which tests any URL
  * - `isValidPipelineUrl` *(this one)* which tests just promptbook URL
  */
-export declare function isValidUrl(url: unknown): url is string_url;
+export declare function isValidUrl(url: really_unknown): url is string_url;

package/esm/typings/src/utils/validators/uuid/isValidUuid.d.ts

@@ -1,5 +1,6 @@
 import type { string_uuid } from '../../../types/typeAliases';
+import type { really_unknown } from '../../organization/really_unknown';
 /**
  * Checks if value is valid uuid
  */
-export declare function isValidUuid(value: unknown): value is string_uuid;
+export declare function isValidUuid(value: really_unknown): value is string_uuid;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/openai",
-    "version": "0.61.0-9",
+    "version": "0.62.0-0",
     "description": "Supercharge your use of large language models",
     "private": false,
     "sideEffects": false,
@@ -36,7 +36,7 @@
     "dependencies": {
         "colors": "1.4.0",
         "openai": "4.46.1",
-        "spacetrim": "0.11.37"
+        "spacetrim": "0.11.39"
     },
     "funding": [
         {
@@ -49,7 +49,7 @@
         }
     ],
     "peerDependencies": {
-        "@promptbook/core": "0.61.0-9"
+        "@promptbook/core": "0.62.0-0"
     },
     "main": "./umd/index.umd.js",
     "module": "./esm/index.es.js",

package/umd/index.umd.js

@@ -90,6 +90,18 @@
         }
     }
 
+    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;
@@ -105,12 +117,22 @@
             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];
@@ -464,6 +486,7 @@
      * @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
      */
 
     /**
@@ -503,6 +526,168 @@
         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
      */
@@ -922,35 +1107,46 @@
          */
         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__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
@@ -977,14 +1173,16 @@
                             }
                             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,
-                                    // <- [🤹‍♂️]
+                                    // <- [🗯]
                                 }];
                     }
                 });
@@ -995,25 +1193,29 @@
          */
         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__default["default"].bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
@@ -1037,14 +1239,16 @@
                             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,
-                                    // <- [🤹‍♂️]
+                                    // <- [🗯]
                                 }];
                     }
                 });
@@ -1055,23 +1259,23 @@
          */
         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) {
@@ -1092,14 +1296,16 @@
                             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,
-                                    // <- [🤹‍♂️]
+                                    // <- [🗯]
                                 }];
                     }
                 });
@@ -1116,9 +1322,9 @@
             });
             if (model === undefined) {
                 throw new UnexpectedError(spaceTrim__default["default"](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                        ");
                 }));
             }
@@ -1162,12 +1368,13 @@
      * 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
 
     exports.OPENAI_MODELS = OPENAI_MODELS;