@promptbook/openai 0.104.0 → 0.105.0-0

package/README.md

@@ -27,6 +27,10 @@ Turn your company's scattered knowledge into AI ready Books
 
 
 
+<blockquote style="color: #ff8811">
+    <b>⚠ Warning:</b> This is a pre-release version of the library. It is not yet ready for production use. Please look at <a href="https://www.npmjs.com/package/@promptbook/core?activeTab=versions">latest stable release</a>.
+</blockquote>
+
 ## 📦 Package `@promptbook/openai`
 
 - Promptbooks are [divided into several](#-packages) packages, all are published from [single monorepo](https://github.com/webgptorg/promptbook).

package/esm/index.es.js

@@ -19,7 +19,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.104.0';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-0';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -182,7 +182,7 @@ const UNCERTAIN_ZERO_VALUE = $deepFreeze({ value: 0, isUncertain: true });
  *
  * @public exported from `@promptbook/core`
  */
-$deepFreeze({
+const ZERO_USAGE = $deepFreeze({
     price: ZERO_VALUE,
     input: {
         tokensCount: ZERO_VALUE,
@@ -2901,6 +2901,82 @@ resultContent, rawResponse) {
  * TODO: [🤝] DRY Maybe some common abstraction between `computeOpenAiUsage` and `computeAnthropicClaudeUsage`
  */
 
+/**
+ * Function `addUsage` will add multiple usages into one
+ *
+ * Note: If you provide 0 values, it returns ZERO_USAGE
+ *
+ * @public exported from `@promptbook/core`
+ */
+function addUsage(...usageItems) {
+    return usageItems.reduce((acc, item) => {
+        var _a;
+        acc.price.value += ((_a = item.price) === null || _a === void 0 ? void 0 : _a.value) || 0;
+        for (const key of Object.keys(acc.input)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            //@ts-ignore
+            if (item.input[key]) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                acc.input[key].value += item.input[key].value || 0;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                if (item.input[key].isUncertain) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    acc.input[key].isUncertain = true;
+                }
+            }
+        }
+        for (const key of Object.keys(acc.output)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            //@ts-ignore
+            if (item.output[key]) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                acc.output[key].value += item.output[key].value || 0;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                if (item.output[key].isUncertain) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    acc.output[key].isUncertain = true;
+                }
+            }
+        }
+        return acc;
+    }, deepClone(ZERO_USAGE));
+}
+
+/**
+ * Async version of Array.forEach
+ *
+ * @param array - Array to iterate over
+ * @param options - Options for the function
+ * @param callbackfunction - Function to call for each item
+ * @public exported from `@promptbook/utils`
+ * @deprecated [🪂] Use queues instead
+ */
+async function forEachAsync(array, options, callbackfunction) {
+    const { maxParallelCount = Infinity } = options;
+    let index = 0;
+    let runningTasks = [];
+    const tasks = [];
+    for (const item of array) {
+        const currentIndex = index++;
+        const task = callbackfunction(item, currentIndex, array);
+        tasks.push(task);
+        runningTasks.push(task);
+        /* not await */ Promise.resolve(task).then(() => {
+            runningTasks = runningTasks.filter((runningTask) => runningTask !== task);
+        });
+        if (maxParallelCount < runningTasks.length) {
+            await Promise.race(runningTasks);
+        }
+    }
+    await Promise.all(tasks);
+}
+
 /**
  * Maps Promptbook tools to OpenAI tools.
  *
@@ -3096,83 +3172,180 @@ class OpenAiCompatibleExecutionTools {
                 content: msg.content,
             }));
         }
-        const rawRequest = {
-            ...modelSettings,
-            messages: [
-                ...(currentModelRequirements.systemMessage === undefined
-                    ? []
-                    : [
-                        {
-                            role: 'system',
-                            content: currentModelRequirements.systemMessage,
-                        },
-                    ]),
-                ...threadMessages,
-                {
-                    role: 'user',
-                    content: rawPromptContent,
-                },
-            ],
-            user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
-            tools: currentModelRequirements.tools === undefined
-                ? undefined
-                : mapToolsToOpenAi(currentModelRequirements.tools),
+        const messages = [
+            ...(currentModelRequirements.systemMessage === undefined
+                ? []
+                : [
+                    {
+                        role: 'system',
+                        content: currentModelRequirements.systemMessage,
+                    },
+                ]),
+            ...threadMessages,
+            {
+                role: 'user',
+                content: rawPromptContent,
+            },
+        ];
+        let totalUsage = {
+            price: uncertainNumber(0),
+            input: {
+                tokensCount: uncertainNumber(0),
+                charactersCount: uncertainNumber(0),
+                wordsCount: uncertainNumber(0),
+                sentencesCount: uncertainNumber(0),
+                linesCount: uncertainNumber(0),
+                paragraphsCount: uncertainNumber(0),
+                pagesCount: uncertainNumber(0),
+            },
+            output: {
+                tokensCount: uncertainNumber(0),
+                charactersCount: uncertainNumber(0),
+                wordsCount: uncertainNumber(0),
+                sentencesCount: uncertainNumber(0),
+                linesCount: uncertainNumber(0),
+                paragraphsCount: uncertainNumber(0),
+                pagesCount: uncertainNumber(0),
+            },
         };
+        const toolCalls = [];
         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.chat.completions.create(rawRequest)))
-                .catch((error) => {
-                assertsError(error);
-                if (this.options.isVerbose) {
-                    console.info(colors.bgRed('error'), error);
-                }
-                throw error;
-            });
+        const tools = 'tools' in prompt && Array.isArray(prompt.tools) ? prompt.tools : currentModelRequirements.tools;
+        let isLooping = true;
+        while (isLooping) {
+            const rawRequest = {
+                ...modelSettings,
+                messages,
+                user: (_a = this.options.userId) === null || _a === void 0 ? void 0 : _a.toString(),
+                tools: tools === undefined ? undefined : mapToolsToOpenAi(tools),
+            };
             if (this.options.isVerbose) {
-                console.info(colors.bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
+                console.info(colors.bgWhite('rawRequest'), JSON.stringify(rawRequest, null, 4));
             }
-            const complete = $getCurrentDate();
-            if (!rawResponse.choices[0]) {
-                throw new PipelineExecutionError(`No choises from ${this.title}`);
-            }
-            if (rawResponse.choices.length > 1) {
-                // TODO: This should be maybe only warning
-                throw new PipelineExecutionError(`More than one choise from ${this.title}`);
-            }
-            const resultContent = rawResponse.choices[0].message.content;
-            const usage = this.computeUsage(content || '', resultContent || '', rawResponse);
-            if (resultContent === null) {
-                throw new PipelineExecutionError(`No response message from ${this.title}`);
-            }
-            return exportJson({
-                name: 'promptResult',
-                message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
-                order: [],
-                value: {
-                    content: resultContent,
-                    modelName: rawResponse.model || modelName,
-                    timing: {
-                        start,
-                        complete,
+            try {
+                const rawResponse = await this.limiter
+                    .schedule(() => this.makeRequestWithNetworkRetry(() => client.chat.completions.create(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));
+                }
+                if (!rawResponse.choices[0]) {
+                    throw new PipelineExecutionError(`No choises from ${this.title}`);
+                }
+                const responseMessage = rawResponse.choices[0].message;
+                messages.push(responseMessage);
+                const usage = this.computeUsage(content || '', responseMessage.content || '', rawResponse);
+                totalUsage = addUsage(totalUsage, usage);
+                if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
+                    await forEachAsync(responseMessage.tool_calls, {}, async (toolCall) => {
+                        const functionName = toolCall.function.name;
+                        const functionArgs = toolCall.function.arguments;
+                        const executionTools = this.options
+                            .executionTools;
+                        if (!executionTools || !executionTools.script) {
+                            throw new PipelineExecutionError(`Model requested tool '${functionName}' but no executionTools.script were provided in OpenAiCompatibleExecutionTools options`);
+                        }
+                        // TODO: [DRY] Use some common tool caller
+                        const scriptTools = Array.isArray(executionTools.script)
+                            ? executionTools.script
+                            : [executionTools.script];
+                        let functionResponse;
+                        try {
+                            const scriptTool = scriptTools[0]; // <- TODO: [🧠] Which script tool to use?
+                            functionResponse = await scriptTool.execute({
+                                scriptLanguage: 'javascript',
+                                script: `
+                                    const args = ${functionArgs};
+                                    return await ${functionName}(args);
+                                `,
+                                parameters: {}, // <- TODO: [🧠] What parameters to pass?
+                            });
+                        }
+                        catch (error) {
+                            assertsError(error);
+                            functionResponse = `Error: ${error.message}`;
+                        }
+                        messages.push({
+                            role: 'tool',
+                            tool_call_id: toolCall.id,
+                            content: functionResponse,
+                        });
+                        toolCalls.push({
+                            name: functionName,
+                            arguments: functionArgs,
+                            result: functionResponse,
+                            rawToolCall: toolCall,
+                        });
+                    });
+                    continue;
+                }
+                const complete = $getCurrentDate();
+                const resultContent = responseMessage.content;
+                if (resultContent === null) {
+                    throw new PipelineExecutionError(`No response message from ${this.title}`);
+                }
+                isLooping = false;
+                return exportJson({
+                    name: 'promptResult',
+                    message: `Result of \`OpenAiCompatibleExecutionTools.callChatModel\``,
+                    order: [],
+                    value: {
+                        content: resultContent,
+                        modelName: rawResponse.model || modelName,
+                        timing: {
+                            start,
+                            complete,
+                        },
+                        usage: totalUsage,
+                        toolCalls,
+                        rawPromptContent,
+                        rawRequest,
+                        rawResponse,
                     },
-                    usage,
-                    rawPromptContent,
-                    rawRequest,
-                    rawResponse,
-                    // <- [🗯]
-                },
-            });
-        }
-        catch (error) {
-            assertsError(error);
-            // Check if this is an unsupported parameter error
-            if (!isUnsupportedParameterError(error)) {
-                // If we have attemptStack, include it in the error message
-                if (attemptStack.length > 0) {
+                });
+            }
+            catch (error) {
+                isLooping = false;
+                assertsError(error);
+                // Check if this is an unsupported parameter error
+                if (!isUnsupportedParameterError(error)) {
+                    // If we have attemptStack, include it in the error message
+                    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;
+                }
+                // Parse which parameter is unsupported
+                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;
+                }
+                // Create a unique key for this model + parameter combination to prevent infinite loops
+                const retryKey = `${modelName}-${unsupportedParameter}`;
+                if (retriedUnsupportedParameters.has(retryKey)) {
+                    // Already retried this parameter, throw the error with attemptStack
+                    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}` +
@@ -3182,52 +3355,25 @@ class OpenAiCompatibleExecutionTools {
                             .join('\n') +
                         `\nFinal error: ${error.message}`);
                 }
-                throw error;
-            }
-            // Parse which parameter is unsupported
-            const unsupportedParameter = parseUnsupportedParameterError(error.message);
-            if (!unsupportedParameter) {
+                // Mark this parameter as retried
+                retriedUnsupportedParameters.add(retryKey);
+                // Log warning in verbose mode
                 if (this.options.isVerbose) {
-                    console.warn(colors.bgYellow('Warning'), 'Could not parse unsupported parameter from error:', error.message);
+                    console.warn(colors.bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
                 }
-                throw error;
-            }
-            // Create a unique key for this model + parameter combination to prevent infinite loops
-            const retryKey = `${modelName}-${unsupportedParameter}`;
-            if (retriedUnsupportedParameters.has(retryKey)) {
-                // Already retried this parameter, throw the error with attemptStack
+                // Add to attemptStack
                 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}`);
-            }
-            // Mark this parameter as retried
-            retriedUnsupportedParameters.add(retryKey);
-            // Log warning in verbose mode
-            if (this.options.isVerbose) {
-                console.warn(colors.bgYellow('Warning'), `Removing unsupported parameter '${unsupportedParameter}' for model '${modelName}' and retrying request`);
+                // Remove the unsupported parameter and retry
+                const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
+                return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
             }
-            // Add to attemptStack
-            attemptStack.push({
-                modelName,
-                unsupportedParameter,
-                errorMessage: error.message,
-                stripped: true,
-            });
-            // Remove the unsupported parameter and retry
-            const modifiedModelRequirements = removeUnsupportedModelRequirement(currentModelRequirements, unsupportedParameter);
-            return this.callChatModelWithRetry(prompt, modifiedModelRequirements, attemptStack, retriedUnsupportedParameters);
         }
+        throw new PipelineExecutionError(`Tool calling loop did not return a result from ${this.title}`);
     }
     /**
      * Calls OpenAI API to use a complete model.
@@ -4543,7 +4689,7 @@ const ALL_ERRORS = {
  *
  * @public exported from `@promptbook/utils`
  */
-function deserializeError(error) {
+function deserializeError(error, isStackAddedToMessage = true) {
     const { name, stack, id } = error; // Added id
     let { message } = error;
     let ErrorClass = ALL_ERRORS[error.name];
@@ -4551,7 +4697,7 @@ function deserializeError(error) {
         ErrorClass = Error;
         message = `${name}: ${message}`;
     }
-    if (stack !== undefined && stack !== '') {
+    if (isStackAddedToMessage && stack !== undefined && stack !== '') {
         message = spaceTrim$2((block) => `
                 ${block(message)}