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

package/esm/index.es.js

@@ -3,8 +3,8 @@ import { forTime } from 'waitasecond';
 import { randomBytes } from 'crypto';
 import { LoremIpsum } from 'lorem-ipsum';
 import 'path';
-import 'crypto-js';
-import 'crypto-js/enc-hex';
+import { SHA256 } from 'crypto-js';
+import hexEncoder from 'crypto-js/enc-hex';
 import moment from 'moment';
 
 // ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
@@ -21,7 +21,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.105.0-15';
+const PROMPTBOOK_ENGINE_VERSION = '0.105.0-16';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2537,6 +2537,19 @@ class ParseError extends Error {
  * 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
  *
@@ -2564,6 +2577,18 @@ class ParseError extends Error {
  * 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 SHA256(hexEncoder.parse(spaceTrim$2(valueToString(value)))).toString( /* hex */);
+}
+/**
+ * TODO: [🥬][🥬] Use this ACRY
+ */
+
 /**
  * Makes first letter of a string uppercase
  *
@@ -5857,6 +5882,432 @@ class StyleCommitmentDefinition extends BaseCommitmentDefinition {
  * [💞] 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$2((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(`
+            # 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(`
+                    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((block) => `
+                Teammates:
+                ${block(teamEntries
+            .map((entry) => {
+            const whenToConsult = entry.teammate.instructions || 'Use when their expertise is needed.';
+            return spaceTrim$1(() => `
+                                    - ${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
  *
@@ -6851,6 +7302,7 @@ const COMMITMENT_REGISTRY = [
     new DictionaryCommitmentDefinition(),
     new OpenCommitmentDefinition(),
     new ClosedCommitmentDefinition(),
+    new TeamCommitmentDefinition(),
     new UseBrowserCommitmentDefinition(),
     new UseSearchEngineCommitmentDefinition(),
     new UseTimeCommitmentDefinition(),