@promptbook/utils 0.107.0-0 → 0.108.0-0

package/esm/index.es.js

@@ -18,7 +18,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.107.0-0';
+const PROMPTBOOK_ENGINE_VERSION = '0.108.0-0';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2804,13 +2804,125 @@ function escapePromptParameterValue(value, options) {
     return value.replace(pattern, '\\$&');
 }
 /**
- * Builds the parameter name used in prompt placeholders.
+ * Builds numeric parameter name used in prompt placeholders.
  *
  * @param index Zero-based parameter index.
  */
-function buildParameterName(index) {
+function buildNumericParameterName(index) {
     return `${index + 1}`;
 }
+/**
+ * Builds alphabetic parameter name used in prompt placeholders.
+ *
+ * @param index Zero-based parameter index.
+ */
+function buildAlphabeticParameterName(index) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+    let result = '';
+    let remaining = index;
+    while (remaining >= 0) {
+        result = alphabet[remaining % alphabet.length] + result;
+        remaining = Math.floor(remaining / alphabet.length) - 1;
+    }
+    return result;
+}
+/**
+ * Converts a positive integer into a Roman numeral string.
+ *
+ * @param value Positive integer value.
+ */
+function toRomanNumeral(value) {
+    const romanTable = [
+        { symbol: 'M', value: 1000 },
+        { symbol: 'CM', value: 900 },
+        { symbol: 'D', value: 500 },
+        { symbol: 'CD', value: 400 },
+        { symbol: 'C', value: 100 },
+        { symbol: 'XC', value: 90 },
+        { symbol: 'L', value: 50 },
+        { symbol: 'XL', value: 40 },
+        { symbol: 'X', value: 10 },
+        { symbol: 'IX', value: 9 },
+        { symbol: 'V', value: 5 },
+        { symbol: 'IV', value: 4 },
+        { symbol: 'I', value: 1 },
+    ];
+    let remaining = Math.max(1, Math.floor(value));
+    let result = '';
+    for (const entry of romanTable) {
+        while (remaining >= entry.value) {
+            result += entry.symbol;
+            remaining -= entry.value;
+        }
+    }
+    return result;
+}
+/**
+ * Builds Roman numeral parameter name used in prompt placeholders.
+ *
+ * @param index Zero-based parameter index.
+ */
+function buildRomanParameterName(index) {
+    return toRomanNumeral(index + 1);
+}
+/**
+ * Creates a parameter name builder that prefixes another builder.
+ *
+ * @param prefix Prefix to add.
+ * @param builder Base builder to wrap.
+ */
+function buildPrefixedParameterName(prefix, builder) {
+    return (index) => `${prefix}${builder(index)}`;
+}
+/**
+ * Ordered list of strategies for parameter naming.
+ */
+const PARAMETER_NAME_STRATEGIES = [
+    { buildName: buildNumericParameterName },
+    { buildName: buildAlphabeticParameterName },
+    { buildName: buildRomanParameterName },
+    { buildName: buildPrefixedParameterName('p', buildNumericParameterName) },
+    { buildName: buildPrefixedParameterName('p', buildAlphabeticParameterName) },
+];
+/**
+ * Collects bracketed tokens from parameter values to avoid placeholder collisions.
+ *
+ * @param values Parameter values to scan.
+ */
+function collectBracketedParameterTokens(values) {
+    const tokens = new Set();
+    for (const value of values) {
+        const pattern = /{(\w+)}/g;
+        let match;
+        while ((match = pattern.exec(value)) !== null) {
+            const token = match[1];
+            if (token) {
+                tokens.add(token);
+            }
+        }
+    }
+    return tokens;
+}
+/**
+ * Builds parameter names used in prompt placeholders while avoiding collisions.
+ *
+ * @param values Parameter values to scan for conflicting tokens.
+ */
+function buildParameterNames(values) {
+    const count = values.length;
+    if (count === 0) {
+        return [];
+    }
+    const conflicts = collectBracketedParameterTokens(values);
+    for (const strategy of PARAMETER_NAME_STRATEGIES) {
+        const names = Array.from({ length: count }, (_, index) => strategy.buildName(index));
+        const hasConflict = names.some((name) => conflicts.has(name));
+        if (!hasConflict) {
+            return names;
+        }
+    }
+    return Array.from({ length: count }, (_, index) => `${REPLACING_NONCE}${index + 1}`);
+}
 /**
  * Formats the placeholder used in the prompt body for a parameter.
  *
@@ -2865,26 +2977,40 @@ function prompt(strings, ...values) {
         return new PromptString(spaceTrim$2(strings.join('')));
     }
     const stringsWithHiddenParameters = strings.map((stringsItem) => hideBrackets(stringsItem));
-    const parameterEntries = values.map((value, index) => {
-        const name = buildParameterName(index);
+    const parameterMetadata = values.map((value) => {
         const isPrompt = isPromptString(value);
         const stringValue = isPrompt ? value.toString() : valueToString(value);
         const isInline = isPrompt ? true : shouldInlineParameterValue(stringValue);
         const jsonValue = !isPrompt && !isInline ? normalizeJsonString(stringValue) : null;
+        return { isPrompt, stringValue, isInline, jsonValue };
+    });
+    const parameterNames = buildParameterNames(parameterMetadata.map((entry) => entry.stringValue));
+    const parameterEntries = parameterMetadata.map((entry, index) => {
+        var _a;
+        const name = (_a = parameterNames[index]) !== null && _a !== void 0 ? _a : buildNumericParameterName(index);
         const promptMarker = `${REPLACING_NONCE}prompt-${index}`;
         const parameterMarker = `${REPLACING_NONCE}parameter-${index}`;
-        const templateValue = isPrompt
+        const templateValue = entry.isPrompt
             ? promptMarker
-            : isInline
-                ? escapePromptParameterValue(stringValue, { includeBraces: false })
+            : entry.isInline
+                ? escapePromptParameterValue(entry.stringValue, { includeBraces: false })
                 : parameterMarker;
-        return { name, stringValue, jsonValue, isPrompt, isInline, promptMarker, parameterMarker, templateValue };
+        return {
+            name,
+            stringValue: entry.stringValue,
+            jsonValue: entry.jsonValue,
+            isPrompt: entry.isPrompt,
+            isInline: entry.isInline,
+            promptMarker,
+            parameterMarker,
+            templateValue,
+        };
     });
     const parameters = Object.fromEntries(parameterEntries.map((entry) => [entry.name, entry.templateValue]));
-    const parameterNames = parameterEntries.map((entry) => entry.name);
+    const parameterNamesOrdered = parameterEntries.map((entry) => entry.name);
     // Combine strings and values
     let pipelineString = stringsWithHiddenParameters.reduce((result, stringsItem, i) => {
-        const parameterName = parameterNames[i];
+        const parameterName = parameterNamesOrdered[i];
         return parameterName === undefined
             ? `${result}${stringsItem}`
             : `${result}${stringsItem}${formatParameterPlaceholder(parameterName)}`;
@@ -2897,7 +3023,7 @@ function prompt(strings, ...values) {
         if (!(error instanceof PipelineExecutionError)) {
             throw error;
         }
-        console.error({ pipelineString, parameters, parameterNames, error });
+        console.error({ pipelineString, parameters, parameterNames: parameterNamesOrdered, error });
         throw new UnexpectedError(spaceTrim$2((block) => `
                     Internal error in prompt template literal
                   
@@ -2912,9 +3038,7 @@ function prompt(strings, ...values) {
             continue;
         }
         if (!entry.isInline) {
-            pipelineString = pipelineString
-                .split(entry.parameterMarker)
-                .join(formatParameterPlaceholder(entry.name));
+            pipelineString = pipelineString.split(entry.parameterMarker).join(formatParameterPlaceholder(entry.name));
         }
     }
     const structuredParameters = parameterEntries.filter((entry) => !entry.isPrompt && !entry.isInline);