@promptbook/remote-server 0.112.0-70 → 0.112.0-72

package/esm/index.es.js

@@ -40,7 +40,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-70';
+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
@@ -14945,7 +14945,9 @@ const octopus3dAvatarVisual = {
         };
         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;
@@ -15031,7 +15033,11 @@ const octopus3dAvatarVisual = {
             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 +
@@ -15040,7 +15046,11 @@ const octopus3dAvatarVisual = {
                     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);
     },
 };
@@ -15201,7 +15211,8 @@ function createOctopusTentacleStrokes(options) {
             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,
         };
@@ -15266,8 +15277,7 @@ function drawTentacleStroke(context, tentacleStroke, palette) {
         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();
@@ -23462,6 +23472,212 @@ const DEFAULT_LIST_TIMEOUTS_LIMIT = 20;
  * @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$1(`
+            ${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.
  *
@@ -23488,22 +23704,14 @@ const parseTimeoutToolArgs = {
      * 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$1(`
-                    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$1(`
-                    Timeout \`timeoutId\` is required unless you pass \`allActive: true\`.
-                `));
-        }
-        return { timeoutId };
+        return { timeoutId: target.timeoutId };
     },
     /**
      * Parses `list_timeouts` input.
@@ -23534,106 +23742,14 @@ const parseTimeoutToolArgs = {
      * 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$1(`
-                    Timeout update must target either one \`timeoutId\` or \`allActive: true\`, not both.
-                `));
-        }
-        if (!timeoutId && !allActive) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    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$1(`
-                        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$1(`
-                        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$1(`
-                    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$1(`
-                        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$1(`
-                        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$1(`
-                        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$1(`
-                        Bulk timeout update only supports the \`paused\` field.
-                    `));
-            }
-            return {
-                allActive: true,
-                paused: patch.paused,
-            };
-        }
-        if (!timeoutId) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    Timeout \`timeoutId\` is required for single-timeout updates.
-                `));
-        }
-        if (Object.keys(patch).length === 0) {
-            throw new PipelineExecutionError(spaceTrim$1(`
-                    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);
     },
 };