@promptbook/ollama 0.104.0 → 0.105.0-1

package/esm/typings/src/config.d.ts

@@ -213,6 +213,12 @@ export declare const DEFAULT_INTERMEDIATE_FILES_STRATEGY: IntermediateFilesStrat
  * @public exported from `@promptbook/core`
  */
 export declare const DEFAULT_MAX_PARALLEL_COUNT = 5;
+/**
+ * The maximum depth to which recursion can occur
+ *
+ * @public exported from `@promptbook/core`
+ */
+export declare const DEFAULT_MAX_RECURSION = 10;
 /**
  * The maximum number of attempts to execute LLM task before giving up
  *

package/esm/typings/src/errors/utils/deserializeError.d.ts

@@ -4,4 +4,4 @@ import type { ErrorJson } from './ErrorJson';
  *
  * @public exported from `@promptbook/utils`
  */
-export declare function deserializeError(error: ErrorJson): Error;
+export declare function deserializeError(error: ErrorJson, isStackAddedToMessage?: boolean): Error;

package/esm/typings/src/execution/PromptResult.d.ts

@@ -1,4 +1,5 @@
 import type { string_date_iso8601, string_model_name, string_prompt } from '../types/typeAliases';
+import type { TODO_any } from '../utils/organization/TODO_any';
 import type { TODO_object } from '../utils/organization/TODO_object';
 import type { EmbeddingVector } from './EmbeddingVector';
 import type { Usage } from './Usage';
@@ -21,7 +22,29 @@ export type CompletionPromptResult = CommonPromptResult;
  *
  * Note: [🚉] This is fully serializable as JSON
  */
-export type ChatPromptResult = CommonPromptResult & {};
+export type ChatPromptResult = CommonPromptResult & {
+    /**
+     * Optional tool calls made during the execution
+     */
+    readonly toolCalls?: ReadonlyArray<{
+        /**
+         * Name of the tool
+         */
+        readonly name: string;
+        /**
+         * Arguments of the tool call
+         */
+        readonly arguments: string;
+        /**
+         * Result of the tool call
+         */
+        readonly result: string;
+        /**
+         * Raw tool call from the model
+         */
+        readonly rawToolCall: TODO_any;
+    }>;
+};
 /**
  * Image prompt result
  *

package/esm/typings/src/llm-providers/openai/OpenAiCompatibleExecutionToolsOptions.d.ts

@@ -1,5 +1,6 @@
 import type { ClientOptions } from 'openai';
 import type { CommonToolsOptions } from '../../execution/CommonToolsOptions';
+import type { ExecutionTools } from '../../execution/ExecutionTools';
 import type { RemoteClientOptions } from '../../remote-server/types/RemoteClientOptions';
 /**
  * Options for `createOpenAiCompatibleExecutionTools` and `OpenAiCompatibleExecutionTools`
@@ -28,6 +29,10 @@ export type OpenAiCompatibleExecutionToolsNonProxiedOptions = CommonToolsOptions
      * @example 'https://api.deepseek.com/v1' (DeepSeek)
      */
     baseURL?: string;
+    /**
+     * Tools for executing the scripts
+     */
+    readonly executionTools?: Pick<ExecutionTools, 'script'>;
     isProxied?: false;
 };
 /**

package/esm/typings/src/types/LlmToolDefinition.d.ts

@@ -16,5 +16,12 @@ export type LlmToolDefinition = {
     /**
      * Parameters of the tool in JSON Schema format
      */
-    readonly parameters: Record<string, unknown>;
+    readonly parameters: {
+        readonly type: 'object';
+        readonly properties: Record<string, {
+            type: string;
+            description?: string;
+        }>;
+        readonly required?: string[];
+    };
 };

package/esm/typings/src/types/Prompt.d.ts

@@ -1,6 +1,7 @@
 import type { FormatCommand } from '../commands/FORMAT/FormatCommand';
 import type { ChatMessage } from '../book-components/Chat/types/ChatMessage';
 import type { Expectations } from '../pipeline/PipelineJson/Expectations';
+import type { LlmToolDefinition } from './LlmToolDefinition';
 import type { ChatModelRequirements } from './ModelRequirements';
 import type { CompletionModelRequirements } from './ModelRequirements';
 import type { EmbeddingModelRequirements } from './ModelRequirements';
@@ -44,6 +45,18 @@ export type ChatPrompt = CommonPrompt & {
      * Optional chat thread (history of previous messages)
      */
     thread?: ChatMessage[];
+    /**
+     * Optional file attachments
+     */
+    attachments?: Array<{
+        name: string;
+        type: string;
+        url: string;
+    }>;
+    /**
+     * Optional tools that can be called by the model
+     */
+    tools?: Array<LlmToolDefinition>;
 };
 /**
  * Image prompt

package/esm/typings/src/utils/misc/parseNumber.d.ts

@@ -10,7 +10,7 @@
  *
  * @public exported from `@promptbook/utils`
  */
-export declare function parseNumber(value: string | number): number;
+export declare function parseNumber(value: string | number | null | undefined): number;
 /**
  * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
  * TODO: [🧠][🌻] Maybe export through `@promptbook/markdown-utils` not `@promptbook/utils`

package/esm/typings/src/utils/random/$generateBookBoilerplate.d.ts

@@ -15,6 +15,10 @@ type GenerateBookBoilerplateOptions = PartialDeep<Omit<AgentBasicInformation, 'p
      * @default 'ENGLISH'
      */
     namePool?: string;
+    /**
+     * Initial rules for the agent
+     */
+    initialRules?: Array<string>;
 };
 /**
  * Generates boilerplate for a new agent book

package/esm/typings/src/utils/random/$randomAgentPersona.d.ts

@@ -5,10 +5,11 @@ import type { string_persona_description } from '../../types/typeAliases';
  * This function selects a random personality profile from a predefined pool
  * of common AI agent characteristics (e.g., friendly, professional, creative).
  *
+ * @param language - The language code (e.g. 'ENGLISH', 'CZECH')
  * @returns A string describing the agent's persona
  * @private internal helper function
  */
-export declare function $randomAgentPersona(): string_persona_description;
+export declare function $randomAgentPersona(language?: string): string_persona_description;
 /**
  * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
  */

package/esm/typings/src/utils/random/$randomAgentRule.d.ts

@@ -0,0 +1,14 @@
+import type { string_persona_description } from '../../types/typeAliases';
+/**
+ * Generates a random agent rule description.
+ *
+ * This function selects a random rule
+ *
+ * @param language - The language code (e.g. 'ENGLISH', 'CZECH')
+ * @returns A string describing the agent's rule
+ * @private internal helper function
+ */
+export declare function $randomAgentRule(language?: string): string_persona_description;
+/**
+ * TODO: [🤶] Maybe export through `@promptbook/utils` or `@promptbook/random` package
+ */

package/esm/typings/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.104.0-19`).
+ * It follows semantic versioning (e.g., `0.105.0-0`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/ollama",
-    "version": "0.104.0",
+    "version": "0.105.0-1",
     "description": "Promptbook: Turn your company's scattered knowledge into AI ready books",
     "private": false,
     "sideEffects": false,
@@ -94,7 +94,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/ollama.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.104.0"
+        "@promptbook/core": "0.105.0-1"
     },
     "dependencies": {
         "bottleneck": "2.19.5",

package/umd/index.umd.js

@@ -25,7 +25,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.104.0';
+    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-1';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -116,7 +116,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    $deepFreeze({
+    const ZERO_USAGE = $deepFreeze({
         price: ZERO_VALUE,
         input: {
             tokensCount: ZERO_VALUE,
@@ -2865,6 +2865,82 @@
         return replacedTemplates;
     }
 
+    /**
+     * 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.
      *
@@ -3060,83 +3136,180 @@
                     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__default["default"].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__default["default"].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__default["default"].bgWhite('rawResponse'), JSON.stringify(rawResponse, null, 4));
+                    console.info(colors__default["default"].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__default["default"].bgRed('error'), error);
+                        }
+                        throw error;
+                    });
+                    if (this.options.isVerbose) {
+                        console.info(colors__default["default"].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__default["default"].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}` +
@@ -3146,52 +3319,25 @@
                                 .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__default["default"].bgYellow('Warning'), 'Could not parse unsupported parameter from error:', error.message);
+                        console.warn(colors__default["default"].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__default["default"].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.