@promptbook/fake-llm 0.105.0-15 → 0.105.0-17

package/umd/index.umd.js

@@ -1,12 +1,13 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('spacetrim'), require('waitasecond'), require('crypto'), require('lorem-ipsum'), require('path'), require('crypto-js'), require('crypto-js/enc-hex'), require('moment')) :
     typeof define === 'function' && define.amd ? define(['exports', 'spacetrim', 'waitasecond', 'crypto', 'lorem-ipsum', 'path', 'crypto-js', 'crypto-js/enc-hex', 'moment'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-fake-llm"] = {}, global.spaceTrim$1, global.waitasecond, global.crypto, global.loremIpsum, null, null, null, global.moment));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["promptbook-fake-llm"] = {}, global.spaceTrim$1, global.waitasecond, global.crypto, global.loremIpsum, null, global.cryptoJs, global.hexEncoder, global.moment));
 })(this, (function (exports, spaceTrim$1, waitasecond, crypto, loremIpsum, path, cryptoJs, hexEncoder, moment) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var spaceTrim__default = /*#__PURE__*/_interopDefaultLegacy(spaceTrim$1);
+    var hexEncoder__default = /*#__PURE__*/_interopDefaultLegacy(hexEncoder);
     var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
 
     // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
@@ -23,7 +24,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-15';
+    const PROMPTBOOK_ENGINE_VERSION = '0.105.0-17';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2539,6 +2540,19 @@
      * TODO: Maybe split `ParseError` and `ApplyError`
      */
 
+    /**
+     * Error thrown when a fetch request fails
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class PromptbookFetchError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'PromptbookFetchError';
+            Object.setPrototypeOf(this, PromptbookFetchError.prototype);
+        }
+    }
+
     /**
      * Index of all javascript errors
      *
@@ -2566,6 +2580,18 @@
      * Note: [💞] Ignore a discrepancy between file name and entity name
      */
 
+    /**
+     * Computes SHA-256 hash of the given object
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function computeHash(value) {
+        return cryptoJs.SHA256(hexEncoder__default["default"].parse(spaceTrim__default["default"](valueToString(value)))).toString( /* hex */);
+    }
+    /**
+     * TODO: [🥬][🥬] Use this ACRY
+     */
+
     /**
      * Makes first letter of a string uppercase
      *
@@ -5859,6 +5885,432 @@
      * [💞] Ignore a discrepancy between file name and entity name
      */
 
+    const urlRegex = /https?:\/\/[^\s]+/gi;
+    const trailingPunctuationRegex = /[),.;!?]+$/;
+    const clauseSeparators = ['.', '?', '!', ';', ','];
+    const conjunctionSeparators = [' and ', ' or '];
+    /**
+     * Parses TEAM commitment content into teammates with instructions.
+     *
+     * @private
+     */
+    function parseTeamCommitmentContent(content, options = {}) {
+        const { strict = false } = options;
+        const lines = content
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const teammates = [];
+        const seenUrls = new Set();
+        for (const line of lines) {
+            const matches = Array.from(line.matchAll(urlRegex));
+            if (matches.length === 0) {
+                if (strict) {
+                    throw new Error(`TEAM commitment expects at least one agent URL, got: "${line}"`);
+                }
+                continue;
+            }
+            for (const [matchIndex, match] of matches.entries()) {
+                const rawUrl = match[0] || '';
+                const cleanedUrl = rawUrl.replace(trailingPunctuationRegex, '');
+                if (!isValidAgentUrl(cleanedUrl)) {
+                    if (strict) {
+                        throw new Error(`Invalid agent URL in TEAM commitment: "${cleanedUrl}"`);
+                    }
+                    continue;
+                }
+                if (seenUrls.has(cleanedUrl)) {
+                    continue;
+                }
+                seenUrls.add(cleanedUrl);
+                const instructionContext = extractInstructionContext(line, matches, matchIndex);
+                const instructions = normalizeInstructionText(instructionContext);
+                const label = createTeammateLabel(cleanedUrl);
+                teammates.push({
+                    url: cleanedUrl,
+                    label,
+                    instructions,
+                });
+            }
+        }
+        return teammates;
+    }
+    function extractInstructionContext(line, matches, matchIndex) {
+        var _a;
+        const match = matches[matchIndex];
+        if (!match || match.index === undefined) {
+            return line.trim();
+        }
+        const rawUrl = match[0] || '';
+        const matchStart = match.index;
+        const matchEnd = matchStart + rawUrl.length;
+        const previousMatch = matches[matchIndex - 1];
+        const nextMatch = matches[matchIndex + 1];
+        const previousEnd = previousMatch && previousMatch.index !== undefined ? previousMatch.index + (((_a = previousMatch[0]) === null || _a === void 0 ? void 0 : _a.length) || 0) : 0;
+        const nextStart = nextMatch && nextMatch.index !== undefined ? nextMatch.index : line.length;
+        const rawPrefix = line.slice(previousEnd, matchStart);
+        const rawSuffix = line.slice(matchEnd, nextStart);
+        const prefix = trimAfterLastDelimiter(rawPrefix);
+        const suffix = trimBeforeLastDelimiter(rawSuffix);
+        if (normalizeInstructionText(suffix)) {
+            return suffix;
+        }
+        if (normalizeInstructionText(prefix)) {
+            return prefix;
+        }
+        return `${prefix} ${suffix}`.trim();
+    }
+    function trimAfterLastDelimiter(text) {
+        const match = findLastDelimiter(text);
+        if (!match) {
+            return text;
+        }
+        return text.slice(match.index + match.length);
+    }
+    function trimBeforeLastDelimiter(text) {
+        const cleaned = text.replace(/^[,;:]\s*/g, '');
+        const match = findLastDelimiter(cleaned);
+        if (!match || match.index <= 0) {
+            return cleaned;
+        }
+        return cleaned.slice(0, match.index);
+    }
+    function findLastDelimiter(text) {
+        let bestIndex = -1;
+        let bestLength = 0;
+        for (const separator of clauseSeparators) {
+            const index = text.lastIndexOf(separator);
+            if (index > bestIndex) {
+                bestIndex = index;
+                bestLength = separator.length;
+            }
+        }
+        const lowerText = text.toLowerCase();
+        for (const separator of conjunctionSeparators) {
+            const index = lowerText.lastIndexOf(separator);
+            if (index > bestIndex) {
+                bestIndex = index;
+                bestLength = separator.length;
+            }
+        }
+        if (bestIndex === -1) {
+            return null;
+        }
+        return { index: bestIndex, length: bestLength };
+    }
+    function normalizeInstructionText(text) {
+        if (!text) {
+            return '';
+        }
+        const withoutUrls = text.replace(urlRegex, '');
+        let normalized = normalizeWhitespaces(withoutUrls).trim();
+        normalized = normalized.replace(/^[,;:]\s*/g, '');
+        normalized = normalized.replace(/^(and|or|the|a|an)\s+/i, '');
+        normalized = normalized.replace(/\s*[,;:]\s*$/g, '');
+        normalized = normalized.replace(/\s+(and|or)\s*$/i, '');
+        normalized = normalizeWhitespaces(normalized).trim();
+        return normalized;
+    }
+    function createTeammateLabel(url) {
+        try {
+            const parsed = new URL(url);
+            const pathParts = parsed.pathname.split('/').filter(Boolean);
+            const lastPart = pathParts[pathParts.length - 1] || parsed.hostname;
+            const decoded = decodeURIComponent(lastPart);
+            const spaced = decoded.replace(/[-_]+/g, ' ').trim();
+            if (!spaced) {
+                return parsed.hostname;
+            }
+            return spaced
+                .split(' ')
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+        }
+        catch (error) {
+            return url;
+        }
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
+    /**
+     * The built-in `fetch' function with a lightweight error handling wrapper as default fetch function used in Promptbook scrapers
+     *
+     * @public exported from `@promptbook/core`
+     */
+    const promptbookFetch = async (urlOrRequest, init) => {
+        try {
+            return await fetch(urlOrRequest, init);
+        }
+        catch (error) {
+            assertsError(error);
+            let url;
+            if (typeof urlOrRequest === 'string') {
+                url = urlOrRequest;
+            }
+            else if (urlOrRequest instanceof Request) {
+                url = urlOrRequest.url;
+            }
+            throw new PromptbookFetchError(spaceTrim__default["default"]((block) => `
+                    Can not fetch "${url}"
+
+                    Fetch error:
+                    ${block(error.message)}
+
+                `));
+        }
+    };
+    /**
+     * TODO: [🧠] Maybe rename because it is not used only for scrapers but also in `$getCompiledBook`
+     */
+
+    const TEAM_TOOL_PREFIX = 'team_chat_';
+    const teamToolFunctions = {};
+    const teamToolTitles = {};
+    /**
+     * TEAM commitment definition
+     *
+     * The `TEAM` commitment defines teammates that the agent can consult via tools.
+     *
+     * Example usage in agent source:
+     *
+     * ```book
+     * TEAM https://agents.ptbk.ik/agents/joe-green
+     * TEAM You can talk with http://localhost:4440/agents/GMw67JN8TXxN7y to discuss the legal aspects.
+     * ```
+     *
+     * @private [??] Maybe export the commitments through some package
+     */
+    class TeamCommitmentDefinition extends BaseCommitmentDefinition {
+        constructor() {
+            super('TEAM');
+        }
+        /**
+         * Short one-line description of TEAM.
+         */
+        get description() {
+            return 'Enable the agent to consult teammate agents via dedicated tools.';
+        }
+        /**
+         * Icon for this commitment.
+         */
+        get icon() {
+            return '??';
+        }
+        /**
+         * Markdown documentation for TEAM commitment.
+         */
+        get documentation() {
+            return spaceTrim$1.spaceTrim(`
+            # TEAM
+
+            Registers teammate agents that the current agent can consult via tools.
+
+            ## Examples
+
+            \`\`\`book
+            Legal Assistant
+
+            PERSONA An expert software developer
+            TEAM You can talk with http://localhost:4440/agents/GMw67JN8TXxN7y to discuss the legal aspects.
+            \`\`\`
+        `);
+        }
+        applyToAgentModelRequirements(requirements, content) {
+            var _a, _b;
+            const trimmedContent = content.trim();
+            if (!trimmedContent) {
+                return requirements;
+            }
+            const teammates = parseTeamCommitmentContent(trimmedContent, { strict: true });
+            if (teammates.length === 0) {
+                return requirements;
+            }
+            const agentName = ((_a = requirements.metadata) === null || _a === void 0 ? void 0 : _a.agentName) || 'Agent';
+            const teamEntries = teammates.map((teammate) => ({
+                toolName: createTeamToolName(teammate.url),
+                teammate,
+                agentName,
+            }));
+            for (const entry of teamEntries) {
+                registerTeamTool(entry);
+            }
+            const existingTools = requirements.tools || [];
+            const updatedTools = [...existingTools];
+            for (const entry of teamEntries) {
+                if (updatedTools.some((tool) => tool.name === entry.toolName)) {
+                    continue;
+                }
+                const instructionSuffix = entry.teammate.instructions
+                    ? `Use when: ${entry.teammate.instructions}`
+                    : 'Use when their expertise is needed.';
+                updatedTools.push({
+                    name: entry.toolName,
+                    description: spaceTrim$1.spaceTrim(`
+                    Consult teammate ${entry.teammate.label} (${entry.teammate.url}).
+                    ${instructionSuffix}
+                `),
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            message: {
+                                type: 'string',
+                                description: 'Question or request to send to the teammate.',
+                            },
+                            context: {
+                                type: 'string',
+                                description: 'Optional background context for the teammate.',
+                            },
+                        },
+                        required: ['message'],
+                    },
+                });
+            }
+            const existingTeammates = ((_b = requirements.metadata) === null || _b === void 0 ? void 0 : _b.teammates) || [];
+            const updatedTeammates = [...existingTeammates];
+            for (const entry of teamEntries) {
+                if (updatedTeammates.some((existing) => existing.url === entry.teammate.url)) {
+                    continue;
+                }
+                updatedTeammates.push({
+                    url: entry.teammate.url,
+                    label: entry.teammate.label,
+                    instructions: entry.teammate.instructions || undefined,
+                    toolName: entry.toolName,
+                });
+            }
+            const teamSystemMessage = spaceTrim$1.spaceTrim((block) => `
+                Teammates:
+                ${block(teamEntries
+            .map((entry) => {
+            const whenToConsult = entry.teammate.instructions || 'Use when their expertise is needed.';
+            return spaceTrim$1.spaceTrim(() => `
+                                    - ${entry.teammate.label} (${entry.teammate.url})
+                                      - Tool: "${entry.toolName}"
+                                      - When to consult: ${whenToConsult}
+                                `);
+        })
+            .join('\n'))}
+            `);
+            return this.appendToSystemMessage({
+                ...requirements,
+                tools: updatedTools,
+                metadata: {
+                    ...requirements.metadata,
+                    teammates: updatedTeammates,
+                },
+            }, teamSystemMessage);
+        }
+        /**
+         * Gets human-readable titles for tool functions provided by this commitment.
+         */
+        getToolTitles() {
+            return { ...teamToolTitles };
+        }
+        /**
+         * Gets tool function implementations for teammate tools.
+         */
+        getToolFunctions() {
+            return { ...teamToolFunctions };
+        }
+    }
+    function createTeamToolName(url) {
+        const hash = computeHash(url).substring(0, 10);
+        return `${TEAM_TOOL_PREFIX}${hash}`;
+    }
+    function registerTeamTool(entry) {
+        teamToolFunctions[entry.toolName] = createTeamToolFunction(entry);
+        teamToolTitles[entry.toolName] = `Consult ${entry.teammate.label}`;
+    }
+    function createTeamToolFunction(entry) {
+        return async (args) => {
+            const message = args.message || args.question || '';
+            if (!message) {
+                const result = {
+                    error: 'Message is required to contact teammate.',
+                    teammate: {
+                        url: entry.teammate.url,
+                        label: entry.teammate.label,
+                        instructions: entry.teammate.instructions,
+                        toolName: entry.toolName,
+                    },
+                };
+                return JSON.stringify(result);
+            }
+            const request = args.context ? `${message}\n\nContext:\n${args.context}` : message;
+            let response = '';
+            let error = null;
+            try {
+                response = await fetchTeammateResponse(entry.teammate.url, request);
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+            }
+            const teammateReply = response || (error ? `Unable to reach teammate. Error: ${error}` : 'No response received.');
+            const result = {
+                teammate: {
+                    url: entry.teammate.url,
+                    label: entry.teammate.label,
+                    instructions: entry.teammate.instructions,
+                    toolName: entry.toolName,
+                },
+                request,
+                response: teammateReply,
+                error,
+                conversation: [
+                    {
+                        sender: 'AGENT',
+                        name: entry.agentName,
+                        content: request,
+                    },
+                    {
+                        sender: 'TEAMMATE',
+                        name: entry.teammate.label,
+                        content: teammateReply,
+                    },
+                ],
+            };
+            return JSON.stringify(result);
+        };
+    }
+    async function fetchTeammateResponse(agentUrl, message) {
+        const url = `${agentUrl.replace(/\/$/, '')}/api/chat`;
+        const response = await promptbookFetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ message }),
+        });
+        if (!response.ok) {
+            throw new Error(`Teammate request failed: ${response.status} ${response.statusText}`);
+        }
+        const rawText = await response.text();
+        return stripToolCallLines(rawText).trim();
+    }
+    function stripToolCallLines(text) {
+        const lines = text.replace(/\r\n/g, '\n').split('\n');
+        return lines
+            .filter((line) => {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+                return true;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                return !('toolCalls' in parsed);
+            }
+            catch (_a) {
+                return true;
+            }
+        })
+            .join('\n');
+    }
+    /**
+     * Note: [💞] Ignore a discrepancy between file name and entity name
+     */
+
     /**
      * USE commitment definition
      *
@@ -6853,6 +7305,7 @@
         new DictionaryCommitmentDefinition(),
         new OpenCommitmentDefinition(),
         new ClosedCommitmentDefinition(),
+        new TeamCommitmentDefinition(),
         new UseBrowserCommitmentDefinition(),
         new UseSearchEngineCommitmentDefinition(),
         new UseTimeCommitmentDefinition(),