@promptbook/browser 0.112.0-71 → 0.112.0-72

package/umd/index.umd.js

@@ -27,7 +27,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-71';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-72';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -7906,7 +7906,9 @@
             };
             const mantleRadiusX = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.horizontalStretch;
             const mantleRadiusY = size * morphologyProfile.body.bodyRadiusRatio * morphologyProfile.body.verticalStretch * 1.1;
-            const mantleRadiusZ = size * morphologyProfile.body.bodyRadiusRatio * (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
+            const mantleRadiusZ = size *
+                morphologyProfile.body.bodyRadiusRatio *
+                (0.9 + (morphologyProfile.body.horizontalStretch - 1) * 0.3);
             const underbodyRadiusX = mantleRadiusX * (0.9 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.08);
             const underbodyRadiusY = mantleRadiusY * (0.44 + morphologyProfile.body.lowerDropRatio * 3.1);
             const underbodyRadiusZ = mantleRadiusZ * 0.78;
@@ -7992,7 +7994,11 @@
                 z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, faceEyeSpacing, faceEyeYOffset),
             }, faceEyeRadiusX, faceEyeRadiusY, mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, size, palette, timeMs, animationPhase + 0.7 + eyeRandom() * 0.6, interaction, morphologyProfile.face.eyeStyle);
             drawProjectedMouth(context, [
-                { x: -mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY) },
+                {
+                    x: -mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, -mouthHalfWidth, mouthY),
+                },
                 {
                     x: size * morphologyProfile.face.mouthCenterOffsetRatio,
                     y: mouthY +
@@ -8001,7 +8007,11 @@
                         interaction.gazeY * size * 0.01,
                     z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, size * morphologyProfile.face.mouthCenterOffsetRatio, mouthY),
                 },
-                { x: mouthHalfWidth, y: mouthY, z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY) },
+                {
+                    x: mouthHalfWidth,
+                    y: mouthY,
+                    z: resolveEllipsoidSurfaceDepth(mantleRadiusX, mantleRadiusY, mantleRadiusZ, mouthHalfWidth, mouthY),
+                },
             ], mantleCenter, headPitch, headYaw, sceneCenterX, sceneCenterY, palette, size);
         },
     };
@@ -8162,7 +8172,8 @@
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.3 + sway * size * 0.012,
             };
             const controlPointTwo = {
-                x: anchorPoint.x + Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
+                x: anchorPoint.x +
+                    Math.sin(orbitAngle) * lateralReach * (0.82 + morphologyProfile.tentacles.swayScale * 0.12),
                 y: anchorPoint.y + flowLength * 0.66,
                 z: anchorPoint.z + Math.cos(orbitAngle) * depthReach * 0.72 + sway * size * 0.02,
             };
@@ -8227,8 +8238,7 @@
             context.beginPath();
             context.moveTo(startPoint.x, startPoint.y);
             context.lineTo(endPoint.x, endPoint.y);
-            context.strokeStyle =
-                tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
+            context.strokeStyle = tentacleStroke.colorBias > 0.6 ? `${palette.secondary}f0` : `${palette.primary}f0`;
             context.lineWidth = width;
             context.lineCap = 'round';
             context.stroke();
@@ -16591,6 +16601,212 @@
      * @private internal USE TIMEOUT constant
      */
     const MAX_LIST_TIMEOUTS_LIMIT = 100;
+    /**
+     * Creates one formatted timeout-argument validation error.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function createTimeoutToolArgsError(message) {
+        return new PipelineExecutionError(spacetrim.spaceTrim(`
+            ${message}
+        `));
+    }
+    /**
+     * Normalizes one optional timeout id string.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function normalizeOptionalTimeoutId(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    /**
+     * Parses timeout target selection for tools that accept either `timeoutId` or `allActive: true`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutTargetSelection(args, options) {
+        const timeoutId = normalizeOptionalTimeoutId(args.timeoutId);
+        const allActive = args.allActive === true;
+        if (timeoutId && allActive) {
+            throw createTimeoutToolArgsError(options.bothMessage);
+        }
+        if (allActive) {
+            return { allActive: true };
+        }
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError(options.missingMessage);
+        }
+        return {
+            timeoutId,
+            allActive: false,
+        };
+    }
+    /**
+     * Parses one explicit `dueAt` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutDueAt(value) {
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            return undefined;
+        }
+        const normalizedDueAt = value.trim();
+        const dueAtTimestamp = Date.parse(normalizedDueAt);
+        if (!Number.isFinite(dueAtTimestamp)) {
+            throw createTimeoutToolArgsError('Timeout `dueAt` must be one valid ISO timestamp.');
+        }
+        return new Date(dueAtTimestamp).toISOString();
+    }
+    /**
+     * Parses one explicit `extendByMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutExtendByMs(value) {
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `extendByMs` must be a positive number of milliseconds.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `recurrenceIntervalMs` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutRecurrenceInterval(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        if (!Number.isFinite(value) || value <= 0) {
+            throw createTimeoutToolArgsError('Timeout `recurrenceIntervalMs` must be a positive number of milliseconds or `null`.');
+        }
+        return Math.floor(value);
+    }
+    /**
+     * Parses one explicit `message` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutMessage(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalizedMessage = value.trim();
+        return normalizedMessage.length > 0 ? normalizedMessage : null;
+    }
+    /**
+     * Parses one explicit `parameters` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutParameters(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw createTimeoutToolArgsError('Timeout `parameters` must be one JSON object.');
+        }
+        return value;
+    }
+    /**
+     * Parses one explicit `paused` update value.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseOptionalTimeoutPaused(value) {
+        return typeof value === 'boolean' ? value : undefined;
+    }
+    /**
+     * Parses patch fields for `update_timeout`.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseTimeoutUpdatePatch(args) {
+        const patch = {};
+        const dueAt = parseOptionalTimeoutDueAt(args.dueAt);
+        const extendByMs = parseOptionalTimeoutExtendByMs(args.extendByMs);
+        const recurrenceIntervalMs = parseOptionalTimeoutRecurrenceInterval(args.recurrenceIntervalMs);
+        const message = parseOptionalTimeoutMessage(args.message);
+        const parameters = parseOptionalTimeoutParameters(args.parameters);
+        const paused = parseOptionalTimeoutPaused(args.paused);
+        if (dueAt !== undefined) {
+            patch.dueAt = dueAt;
+        }
+        if (extendByMs !== undefined) {
+            patch.extendByMs = extendByMs;
+        }
+        if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
+            throw createTimeoutToolArgsError('Timeout update cannot include both `dueAt` and `extendByMs`.');
+        }
+        if (recurrenceIntervalMs !== undefined) {
+            patch.recurrenceIntervalMs = recurrenceIntervalMs;
+        }
+        if (message !== undefined) {
+            patch.message = message;
+        }
+        if (parameters !== undefined) {
+            patch.parameters = parameters;
+        }
+        if (paused !== undefined) {
+            patch.paused = paused;
+        }
+        return patch;
+    }
+    /**
+     * Determines whether the patch contains fields that are only supported for single-timeout updates.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function hasSingleTimeoutOnlyPatchFields(patch) {
+        return (patch.dueAt !== undefined ||
+            patch.extendByMs !== undefined ||
+            patch.recurrenceIntervalMs !== undefined ||
+            patch.message !== undefined ||
+            patch.parameters !== undefined);
+    }
+    /**
+     * Parses bulk timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseBulkTimeoutUpdateArgs(patch) {
+        if (patch.paused === undefined) {
+            throw createTimeoutToolArgsError('Bulk timeout update with `allActive: true` requires `paused` to be explicitly set.');
+        }
+        if (hasSingleTimeoutOnlyPatchFields(patch)) {
+            throw createTimeoutToolArgsError('Bulk timeout update only supports the `paused` field.');
+        }
+        return {
+            allActive: true,
+            paused: patch.paused,
+        };
+    }
+    /**
+     * Parses single-timeout update arguments.
+     *
+     * @private internal utility of USE TIMEOUT
+     */
+    function parseSingleTimeoutUpdateArgs(timeoutId, patch) {
+        if (!timeoutId) {
+            throw createTimeoutToolArgsError('Timeout `timeoutId` is required for single-timeout updates.');
+        }
+        if (Object.keys(patch).length === 0) {
+            throw createTimeoutToolArgsError('Timeout update must include at least one editable field.');
+        }
+        return {
+            timeoutId,
+            patch,
+        };
+    }
     /**
      * Parses and validates `USE TIMEOUT` tool arguments.
      *
@@ -16617,22 +16833,14 @@
          * Parses `cancel_timeout` input.
          */
         cancel(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout cancellation must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (allActive) {
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout cancellation must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout `timeoutId` is required unless you pass `allActive: true`.',
+            });
+            if (target.allActive) {
                 return { allActive: true };
             }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-            }
-            return { timeoutId };
+            return { timeoutId: target.timeoutId };
         },
         /**
          * Parses `list_timeouts` input.
@@ -16663,106 +16871,14 @@
          * Parses `update_timeout` input.
          */
         update(args) {
-            const timeoutId = typeof args.timeoutId === 'string' ? args.timeoutId.trim() : '';
-            const allActive = args.allActive === true;
-            if (timeoutId && allActive) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-            }
-            if (!timeoutId && !allActive) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout update requires one \`timeoutId\` or \`allActive: true\`.
-                `));
-            }
-            const patch = {};
-            if (typeof args.dueAt === 'string' && args.dueAt.trim().length > 0) {
-                const normalizedDueAt = args.dueAt.trim();
-                const dueAtTimestamp = Date.parse(normalizedDueAt);
-                if (!Number.isFinite(dueAtTimestamp)) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Timeout \`dueAt\` must be one valid ISO timestamp.
-                    `));
-                }
-                patch.dueAt = new Date(dueAtTimestamp).toISOString();
-            }
-            if (typeof args.extendByMs === 'number') {
-                if (!Number.isFinite(args.extendByMs) || args.extendByMs <= 0) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Timeout \`extendByMs\` must be a positive number of milliseconds.
-                    `));
-                }
-                patch.extendByMs = Math.floor(args.extendByMs);
-            }
-            if (patch.dueAt !== undefined && patch.extendByMs !== undefined) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout update cannot include both \`dueAt\` and \`extendByMs\`.
-                `));
-            }
-            if (args.recurrenceIntervalMs === null) {
-                patch.recurrenceIntervalMs = null;
-            }
-            else if (typeof args.recurrenceIntervalMs === 'number') {
-                if (!Number.isFinite(args.recurrenceIntervalMs) || args.recurrenceIntervalMs <= 0) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Timeout \`recurrenceIntervalMs\` must be a positive number of milliseconds or \`null\`.
-                    `));
-                }
-                patch.recurrenceIntervalMs = Math.floor(args.recurrenceIntervalMs);
-            }
-            if (args.message === null) {
-                patch.message = null;
-            }
-            else if (typeof args.message === 'string') {
-                const normalizedMessage = args.message.trim();
-                patch.message = normalizedMessage.length > 0 ? normalizedMessage : null;
-            }
-            if (args.parameters !== undefined) {
-                if (!args.parameters || typeof args.parameters !== 'object' || Array.isArray(args.parameters)) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Timeout \`parameters\` must be one JSON object.
-                    `));
-                }
-                patch.parameters = args.parameters;
-            }
-            if (typeof args.paused === 'boolean') {
-                patch.paused = args.paused;
-            }
-            if (allActive) {
-                if (patch.paused === undefined) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Bulk timeout update with \`allActive: true\` requires \`paused\` to be explicitly set.
-                    `));
-                }
-                const hasSingleOnlyPatch = patch.dueAt !== undefined ||
-                    patch.extendByMs !== undefined ||
-                    patch.recurrenceIntervalMs !== undefined ||
-                    patch.message !== undefined ||
-                    patch.parameters !== undefined;
-                if (hasSingleOnlyPatch) {
-                    throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-                }
-                return {
-                    allActive: true,
-                    paused: patch.paused,
-                };
-            }
-            if (!timeoutId) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-            }
-            if (Object.keys(patch).length === 0) {
-                throw new PipelineExecutionError(spacetrim.spaceTrim(`
-                    Timeout update must include at least one editable field.
-                `));
-            }
-            return {
-                timeoutId,
-                patch,
-            };
+            const target = parseTimeoutTargetSelection(args, {
+                bothMessage: 'Timeout update must target either one `timeoutId` or `allActive: true`, not both.',
+                missingMessage: 'Timeout update requires one `timeoutId` or `allActive: true`.',
+            });
+            const patch = parseTimeoutUpdatePatch(args);
+            return target.allActive
+                ? parseBulkTimeoutUpdateArgs(patch)
+                : parseSingleTimeoutUpdateArgs(target.timeoutId, patch);
         },
     };