@promptbook/ollama 0.94.0-1

package/umd/index.umd.js

@@ -0,0 +1,756 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bottleneck'), require('node-fetch'), require('crypto'), require('spacetrim')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'bottleneck', 'node-fetch', 'crypto', 'spacetrim'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-ollama"] = {}, global.Bottleneck, global.fetch, global.crypto, global.spaceTrim));
+})(this, (function (exports, Bottleneck, fetch, crypto, spaceTrim) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var Bottleneck__default = /*#__PURE__*/_interopDefaultLegacy(Bottleneck);
+    var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+    var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim);
+
+    // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
+    /**
+     * The version of the Book language
+     *
+     * @generated
+     * @see https://github.com/webgptorg/book
+     */
+    const BOOK_LANGUAGE_VERSION = '1.0.0';
+    /**
+     * The version of the Promptbook engine
+     *
+     * @generated
+     * @see https://github.com/webgptorg/promptbook
+     */
+    const PROMPTBOOK_ENGINE_VERSION = '0.94.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
+     */
+
+    /**
+     * Name for the Promptbook
+     *
+     * TODO: [🗽] Unite branding and make single place for it
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const NAME = `Promptbook`;
+    /**
+     * Email of the responsible person
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const ADMIN_EMAIL = 'pavol@ptbk.io';
+    /**
+     * Name of the responsible person for the Promptbook on GitHub
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const ADMIN_GITHUB_NAME = 'hejny';
+    // <- TODO: [🧜‍♂️]
+    /**
+     * Default settings for parsing and generating CSV files in Promptbook.
+     *
+     * @public exported from `@promptbook/core`
+     */
+    Object.freeze({
+        delimiter: ',',
+        quoteChar: '"',
+        newline: '\n',
+        skipEmptyLines: true,
+    });
+    /**
+     * Default rate limits (requests per minute)
+     *
+     * Note: Adjust based on the provider tier you are have
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const DEFAULT_MAX_REQUESTS_PER_MINUTE = 60;
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     * TODO: [🧠][🧜‍♂️] Maybe join remoteServerUrl and path into single value
+     */
+
+    /**
+     * Generates random token
+     *
+     * Note: This function is cryptographically secure (it uses crypto.randomBytes internally)
+     *
+     * @private internal helper function
+     * @returns secure random token
+     */
+    function $randomToken(randomness) {
+        return crypto.randomBytes(randomness).toString('hex');
+    }
+    /**
+     * TODO: Maybe use nanoid instead https://github.com/ai/nanoid
+     */
+
+    /**
+     * This error indicates errors during the execution of the pipeline
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class PipelineExecutionError extends Error {
+        constructor(message) {
+            // Added id parameter
+            super(message);
+            this.name = 'PipelineExecutionError';
+            // TODO: [🐙] DRY - Maybe $randomId
+            this.id = `error-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid similar char conflicts   */)}`;
+            Object.setPrototypeOf(this, PipelineExecutionError.prototype);
+        }
+    }
+    /**
+     * TODO: [🧠][🌂] Add id to all errors
+     */
+
+    /**
+     * Make error report URL for the given error
+     *
+     * @private private within the repository
+     */
+    function getErrorReportUrl(error) {
+        const report = {
+            title: `🐜 Error report from ${NAME}`,
+            body: spaceTrim__default["default"]((block) => `
+
+
+            \`${error.name || 'Error'}\` has occurred in the [${NAME}], please look into it @${ADMIN_GITHUB_NAME}.
+
+            \`\`\`
+            ${block(error.message || '(no error message)')}
+            \`\`\`
+
+
+            ## More info:
+
+            - **Promptbook engine version:** ${PROMPTBOOK_ENGINE_VERSION}
+            - **Book language version:** ${BOOK_LANGUAGE_VERSION}
+            - **Time:** ${new Date().toISOString()}
+
+            <details>
+            <summary>Stack trace:</summary>
+
+            ## Stack trace:
+
+            \`\`\`stacktrace
+            ${block(error.stack || '(empty)')}
+            \`\`\`
+            </details>
+
+        `),
+        };
+        const reportUrl = new URL(`https://github.com/webgptorg/promptbook/issues/new`);
+        reportUrl.searchParams.set('labels', 'bug');
+        reportUrl.searchParams.set('assignees', ADMIN_GITHUB_NAME);
+        reportUrl.searchParams.set('title', report.title);
+        reportUrl.searchParams.set('body', report.body);
+        return reportUrl;
+    }
+
+    /**
+     * This error type indicates that the error should not happen and its last check before crashing with some other error
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class UnexpectedError extends Error {
+        constructor(message) {
+            super(spaceTrim.spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: This error should not happen.
+                    It's probably a bug in the pipeline collection
+
+                    Please report issue:
+                    ${block(getErrorReportUrl(new Error(message)).href)}
+
+                    Or contact us on ${ADMIN_EMAIL}
+
+                `));
+            this.name = 'UnexpectedError';
+            Object.setPrototypeOf(this, UnexpectedError.prototype);
+        }
+    }
+
+    /**
+     * Simple wrapper `new Date().toISOString()`
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it is not deterministic because it depends on the current time
+     *
+     * @returns string_date branded type
+     * @public exported from `@promptbook/utils`
+     */
+    function $getCurrentDate() {
+        return new Date().toISOString();
+    }
+
+    /**
+     * Orders JSON object by keys
+     *
+     * @returns The same type of object as the input re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function orderJson(options) {
+        const { value, order } = options;
+        const orderedValue = {
+            ...(order === undefined ? {} : Object.fromEntries(order.map((key) => [key, undefined]))),
+            ...value,
+        };
+        return orderedValue;
+    }
+
+    /**
+     * Freezes the given object and all its nested objects recursively
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it mutates given object
+     * Note: This function mutates the object and returns the original (but mutated-deep-freezed) object
+     *
+     * @returns The same object as the input, but deeply frozen
+     * @public exported from `@promptbook/utils`
+     */
+    function $deepFreeze(objectValue) {
+        if (Array.isArray(objectValue)) {
+            return Object.freeze(objectValue.map((item) => $deepFreeze(item)));
+        }
+        const propertyNames = Object.getOwnPropertyNames(objectValue);
+        for (const propertyName of propertyNames) {
+            const value = objectValue[propertyName];
+            if (value && typeof value === 'object') {
+                $deepFreeze(value);
+            }
+        }
+        Object.freeze(objectValue);
+        return objectValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * This error type indicates that somewhere in the code non-Error object was thrown and it was wrapped into the `WrappedError`
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class WrappedError extends Error {
+        constructor(whatWasThrown) {
+            const tag = `[🤮]`;
+            console.error(tag, whatWasThrown);
+            super(spaceTrim.spaceTrim(`
+                Non-Error object was thrown
+
+                Note: Look for ${tag} in the console for more details
+                Please report issue on ${ADMIN_EMAIL}
+            `));
+            this.name = 'WrappedError';
+            Object.setPrototypeOf(this, WrappedError.prototype);
+        }
+    }
+
+    /**
+     * Helper used in catch blocks to assert that the error is an instance of `Error`
+     *
+     * @param whatWasThrown Any object that was thrown
+     * @returns Nothing if the error is an instance of `Error`
+     * @throws `WrappedError` or `UnexpectedError` if the error is not standard
+     *
+     * @private within the repository
+     */
+    function assertsError(whatWasThrown) {
+        // Case 1: Handle error which was rethrown as `WrappedError`
+        if (whatWasThrown instanceof WrappedError) {
+            const wrappedError = whatWasThrown;
+            throw wrappedError;
+        }
+        // Case 2: Handle unexpected errors
+        if (whatWasThrown instanceof UnexpectedError) {
+            const unexpectedError = whatWasThrown;
+            throw unexpectedError;
+        }
+        // Case 3: Handle standard errors - keep them up to consumer
+        if (whatWasThrown instanceof Error) {
+            return;
+        }
+        // Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
+        throw new WrappedError(whatWasThrown);
+    }
+
+    /**
+     * Checks if the value is [🚉] serializable as JSON
+     * If not, throws an UnexpectedError with a rich error message and tracking
+     *
+     * - Almost all primitives are serializable BUT:
+     * - `undefined` is not serializable
+     * - `NaN` is not serializable
+     * - Objects and arrays are serializable if all their properties are serializable
+     * - Functions are not serializable
+     * - Circular references are not serializable
+     * - `Date` objects are not serializable
+     * - `Map` and `Set` objects are not serializable
+     * - `RegExp` objects are not serializable
+     * - `Error` objects are not serializable
+     * - `Symbol` objects are not serializable
+     * - And much more...
+     *
+     * @throws UnexpectedError if the value is not serializable as JSON
+     * @public exported from `@promptbook/utils`
+     */
+    function checkSerializableAsJson(options) {
+        const { value, name, message } = options;
+        if (value === undefined) {
+            throw new UnexpectedError(`${name} is undefined`);
+        }
+        else if (value === null) {
+            return;
+        }
+        else if (typeof value === 'boolean') {
+            return;
+        }
+        else if (typeof value === 'number' && !isNaN(value)) {
+            return;
+        }
+        else if (typeof value === 'string') {
+            return;
+        }
+        else if (typeof value === 'symbol') {
+            throw new UnexpectedError(`${name} is symbol`);
+        }
+        else if (typeof value === 'function') {
+            throw new UnexpectedError(`${name} is function`);
+        }
+        else if (typeof value === 'object' && Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                checkSerializableAsJson({ name: `${name}[${i}]`, value: value[i], message });
+            }
+        }
+        else if (typeof value === 'object') {
+            if (value instanceof Date) {
+                throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                        \`${name}\` is Date
+
+                        Use \`string_date_iso8601\` instead
+
+                        Additional message for \`${name}\`:
+                        ${block(message || '(nothing)')}
+                    `));
+            }
+            else if (value instanceof Map) {
+                throw new UnexpectedError(`${name} is Map`);
+            }
+            else if (value instanceof Set) {
+                throw new UnexpectedError(`${name} is Set`);
+            }
+            else if (value instanceof RegExp) {
+                throw new UnexpectedError(`${name} is RegExp`);
+            }
+            else if (value instanceof Error) {
+                throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                        \`${name}\` is unserialized Error
+
+                        Use function \`serializeError\`
+
+                        Additional message for \`${name}\`:
+                        ${block(message || '(nothing)')}
+
+                    `));
+            }
+            else {
+                for (const [subName, subValue] of Object.entries(value)) {
+                    if (subValue === undefined) {
+                        // Note: undefined in object is serializable - it is just omited
+                        continue;
+                    }
+                    checkSerializableAsJson({ name: `${name}.${subName}`, value: subValue, message });
+                }
+                try {
+                    JSON.stringify(value); // <- TODO: [0]
+                }
+                catch (error) {
+                    assertsError(error);
+                    throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                            \`${name}\` is not serializable
+
+                            ${block(error.stack || error.message)}
+
+                            Additional message for \`${name}\`:
+                            ${block(message || '(nothing)')}
+                        `));
+                }
+                /*
+                TODO: [0] Is there some more elegant way to check circular references?
+                const seen = new Set();
+                const stack = [{ value }];
+                while (stack.length > 0) {
+                    const { value } = stack.pop()!;
+                    if (typeof value === 'object' && value !== null) {
+                        if (seen.has(value)) {
+                            throw new UnexpectedError(`${name} has circular reference`);
+                        }
+                        seen.add(value);
+                        if (Array.isArray(value)) {
+                            stack.push(...value.map((value) => ({ value })));
+                        } else {
+                            stack.push(...Object.values(value).map((value) => ({ value })));
+                        }
+                    }
+                }
+                */
+                return;
+            }
+        }
+        else {
+            throw new UnexpectedError(spaceTrim__default["default"]((block) => `
+                    \`${name}\` is unknown type
+
+                    Additional message for \`${name}\`:
+                    ${block(message || '(nothing)')}
+                `));
+        }
+    }
+    /**
+     * TODO: Can be return type more type-safe? like `asserts options.value is JsonValue`
+     * TODO: [🧠][main] !!3 In-memory cache of same values to prevent multiple checks
+     * Note: [🐠] This is how `checkSerializableAsJson` + `isSerializableAsJson` together can just retun true/false or rich error message
+     */
+
+    /**
+     * Creates a deep clone of the given object
+     *
+     * Note: This method only works for objects that are fully serializable to JSON and do not contain functions, Dates, or special types.
+     *
+     * @param objectValue The object to clone.
+     * @returns A deep, writable clone of the input object.
+     * @public exported from `@promptbook/utils`
+     */
+    function deepClone(objectValue) {
+        return JSON.parse(JSON.stringify(objectValue));
+        /*
+        TODO: [🧠] Is there a better implementation?
+        > const propertyNames = Object.getOwnPropertyNames(objectValue);
+        > for (const propertyName of propertyNames) {
+        >     const value = (objectValue as really_any)[propertyName];
+        >     if (value && typeof value === 'object') {
+        >         deepClone(value);
+        >     }
+        > }
+        > return Object.assign({}, objectValue);
+        */
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Utility to export a JSON object from a function
+     *
+     * 1) Checks if the value is serializable as JSON
+     * 2) Makes a deep clone of the object
+     * 2) Orders the object properties
+     * 2) Deeply freezes the cloned object
+     *
+     * Note: This function does not mutates the given object
+     *
+     * @returns The same type of object as the input but read-only and re-ordered
+     * @public exported from `@promptbook/utils`
+     */
+    function exportJson(options) {
+        const { name, value, order, message } = options;
+        checkSerializableAsJson({ name, value, message });
+        const orderedValue = 
+        // TODO: Fix error "Type instantiation is excessively deep and possibly infinite."
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        order === undefined
+            ? deepClone(value)
+            : orderJson({
+                value: value,
+                // <- Note: checkSerializableAsJson asserts that the value is serializable as JSON
+                order: order,
+            });
+        $deepFreeze(orderedValue);
+        return orderedValue;
+    }
+    /**
+     * TODO: [🧠] Is there a way how to meaningfully test this utility
+     */
+
+    /**
+     * Execution Tools for calling a local Ollama model via HTTP API
+     *
+     * @public exported from `@promptbook/ollama`
+     */
+    class OllamaExecutionTools {
+        constructor(options) {
+            this.options = options;
+            this.limiter = new Bottleneck__default["default"]({
+                minTime: 60000 / (options.maxRequestsPerMinute || DEFAULT_MAX_REQUESTS_PER_MINUTE),
+            });
+        }
+        get title() {
+            return 'Ollama';
+        }
+        get description() {
+            return 'Local Ollama LLM via HTTP';
+        }
+        async checkConfiguration() {
+            const res = await fetch__default["default"](`${this.options.baseUrl}/models`);
+            if (!res.ok)
+                throw new UnexpectedError(`Failed to reach Ollama API at ${this.options.baseUrl}`);
+        }
+        async listModels() {
+            const res = await fetch__default["default"](`${this.options.baseUrl}/models`);
+            if (!res.ok)
+                throw new UnexpectedError(`Error listing Ollama models: ${res.statusText}`);
+            const data = (await res.json());
+            return data.map((m) => ({ modelName: m.name, modelVariant: 'CHAT' }));
+        }
+        async callChatModel(prompt) {
+            const { content, parameters, modelRequirements } = prompt;
+            if (modelRequirements.modelVariant !== 'CHAT') {
+                throw new PipelineExecutionError('Use callChatModel only for CHAT variant');
+            }
+            const modelName = modelRequirements.modelName || this.options.model;
+            const body = {
+                model: modelName,
+                messages: [
+                    ...(modelRequirements.systemMessage
+                        ? [{ role: 'system', content: modelRequirements.systemMessage }]
+                        : []),
+                    { role: 'user', content: content },
+                ],
+                parameters: parameters,
+            };
+            const start = $getCurrentDate();
+            const res = await this.limiter.schedule(() => fetch__default["default"](`${this.options.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            }));
+            if (!res.ok)
+                throw new PipelineExecutionError(`Ollama API error: ${res.statusText}`);
+            const json = await res.json();
+            const complete = $getCurrentDate();
+            if (!json.choices || !json.choices[0]) {
+                throw new PipelineExecutionError('No choices from Ollama');
+            }
+            const resultContent = json.choices[0].message.content;
+            const usage = { price: { value: 0, isUncertain: true }, input: {}, output: {} }; /* <- !!! */
+            return exportJson({
+                name: 'promptResult',
+                message: 'Result of Ollama',
+                order: [],
+                value: {
+                    content: resultContent,
+                    modelName,
+                    timing: { start, complete },
+                    usage,
+                    rawPromptContent: content,
+                    rawRequest: body,
+                    rawResponse: json,
+                },
+            });
+        }
+    }
+
+    /**
+     * Execution Tools for calling Ollama API
+     *
+     * @public exported from `@promptbook/ollama`
+     */
+    const createOllamaExecutionTools = Object.assign((options) => new OllamaExecutionTools(options), {
+        packageName: '@promptbook/ollama',
+        className: 'OllamaExecutionTools',
+    });
+
+    /**
+     * This error type indicates that some part of the code is not implemented yet
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class NotYetImplementedError extends Error {
+        constructor(message) {
+            super(spaceTrim.spaceTrim((block) => `
+                    ${block(message)}
+
+                    Note: This feature is not implemented yet but it will be soon.
+
+                    If you want speed up the implementation or just read more, look here:
+                    https://github.com/webgptorg/promptbook
+
+                    Or contact us on pavol@ptbk.io
+
+                `));
+            this.name = 'NotYetImplementedError';
+            Object.setPrototypeOf(this, NotYetImplementedError.prototype);
+        }
+    }
+
+    /**
+     * Safely retrieves the global scope object (window in browser, global in Node.js)
+     * regardless of the JavaScript environment in which the code is running
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it access global scope
+     *
+     *  @private internal function of `$Register`
+     */
+    function $getGlobalScope() {
+        return Function('return this')();
+    }
+
+    /**
+     * Normalizes a text string to SCREAMING_CASE (all uppercase with underscores).
+     *
+     * @param text The text string to be converted to SCREAMING_CASE format.
+     * @returns The normalized text in SCREAMING_CASE format.
+     * @example 'HELLO_WORLD'
+     * @example 'I_LOVE_PROMPTBOOK'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_SCREAMING_CASE(text) {
+        let charType;
+        let lastCharType = 'OTHER';
+        let normalizedName = '';
+        for (const char of text) {
+            let normalizedChar;
+            if (/^[a-z]$/.test(char)) {
+                charType = 'LOWERCASE';
+                normalizedChar = char.toUpperCase();
+            }
+            else if (/^[A-Z]$/.test(char)) {
+                charType = 'UPPERCASE';
+                normalizedChar = char;
+            }
+            else if (/^[0-9]$/.test(char)) {
+                charType = 'NUMBER';
+                normalizedChar = char;
+            }
+            else {
+                charType = 'OTHER';
+                normalizedChar = '_';
+            }
+            if (charType !== lastCharType &&
+                !(lastCharType === 'UPPERCASE' && charType === 'LOWERCASE') &&
+                !(lastCharType === 'NUMBER') &&
+                !(charType === 'NUMBER')) {
+                normalizedName += '_';
+            }
+            normalizedName += normalizedChar;
+            lastCharType = charType;
+        }
+        normalizedName = normalizedName.replace(/_+/g, '_');
+        normalizedName = normalizedName.replace(/_?\/_?/g, '/');
+        normalizedName = normalizedName.replace(/^_/, '');
+        normalizedName = normalizedName.replace(/_$/, '');
+        return normalizedName;
+    }
+    /**
+     * TODO: Tests
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'Moje tabule' })).toEqual('/VtG7sR9rRJqwNEdM2/Moje tabule');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: 'ěščřžžýáíúů' })).toEqual('/VtG7sR9rRJqwNEdM2/escrzyaieuu');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj');
+     *     > expect(encodeRoutePath({ uriId: 'VtG7sR9rRJqwNEdM2', name: '  ahoj_ahojAhoj    ahoj  ' })).toEqual('/VtG7sR9rRJqwNEdM2/ahoj-ahoj-ahoj-ahoj');
+     * TODO: [🌺] Use some intermediate util splitWords
+     */
+
+    /**
+     * Normalizes a text string to snake_case format.
+     *
+     * @param text The text string to be converted to snake_case format.
+     * @returns The normalized text in snake_case format.
+     * @example 'hello_world'
+     * @example 'i_love_promptbook'
+     * @public exported from `@promptbook/utils`
+     */
+    function normalizeTo_snake_case(text) {
+        return normalizeTo_SCREAMING_CASE(text).toLowerCase();
+    }
+
+    /**
+     * Global registry for storing and managing registered entities of a given type.
+     *
+     * Note: `$` is used to indicate that this function is not a pure function - it accesses and adds variables in global scope.
+     *
+     * @private internal utility, exported are only singleton instances of this class
+     */
+    class $Register {
+        constructor(registerName) {
+            this.registerName = registerName;
+            const storageName = `_promptbook_${normalizeTo_snake_case(registerName)}`;
+            const globalScope = $getGlobalScope();
+            if (globalScope[storageName] === undefined) {
+                globalScope[storageName] = [];
+            }
+            else if (!Array.isArray(globalScope[storageName])) {
+                throw new UnexpectedError(`Expected (global) ${storageName} to be an array, but got ${typeof globalScope[storageName]}`);
+            }
+            this.storage = globalScope[storageName];
+        }
+        list() {
+            // <- TODO: ReadonlyDeep<ReadonlyArray<TRegistered>>
+            return this.storage;
+        }
+        register(registered) {
+            const { packageName, className } = registered;
+            const existingRegistrationIndex = this.storage.findIndex((item) => item.packageName === packageName && item.className === className);
+            const existingRegistration = this.storage[existingRegistrationIndex];
+            if (!existingRegistration) {
+                this.storage.push(registered);
+            }
+            else {
+                this.storage[existingRegistrationIndex] = registered;
+            }
+            return {
+                registerName: this.registerName,
+                packageName,
+                className,
+                get isDestroyed() {
+                    return false;
+                },
+                destroy() {
+                    throw new NotYetImplementedError(`Registration to ${this.registerName} is permanent in this version of Promptbook`);
+                },
+            };
+        }
+    }
+
+    /**
+     * Register for LLM tools.
+     *
+     * Note: `$` is used to indicate that this interacts with the global scope
+     * @singleton Only one instance of each register is created per build, but there can be more instances across different builds or environments.
+     * @public exported from `@promptbook/core`
+     */
+    const $llmToolsRegister = new $Register('llm_execution_tools_constructors');
+    /**
+     * TODO: [®] DRY Register logic
+     */
+
+    /**
+     * Registration of LLM provider
+     *
+     * Warning: This is not useful for the end user, it is just a side effect of the mechanism that handles all available LLM tools
+     *
+     * @public exported from `@promptbook/ollama`
+     * @public exported from `@promptbook/wizzard`
+     * @public exported from `@promptbook/cli`
+     */
+    const _OllamaRegistration = $llmToolsRegister.register(createOllamaExecutionTools);
+    /**
+     * TODO: [🎶] Naming "constructor" vs "creator" vs "factory"
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    exports.BOOK_LANGUAGE_VERSION = BOOK_LANGUAGE_VERSION;
+    exports.OllamaExecutionTools = OllamaExecutionTools;
+    exports.PROMPTBOOK_ENGINE_VERSION = PROMPTBOOK_ENGINE_VERSION;
+    exports._OllamaRegistration = _OllamaRegistration;
+    exports.createOllamaExecutionTools = createOllamaExecutionTools;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map