@promptbook/components 0.112.0-70 → 0.112.0-72

package/umd/index.umd.js

@@ -30,7 +30,7 @@
      * @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
@@ -4513,7 +4513,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;
@@ -4599,7 +4601,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 +
@@ -4608,7 +4614,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);
         },
     };
@@ -4769,7 +4779,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,
             };
@@ -4834,8 +4845,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();
@@ -17523,6 +17533,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.
      *
@@ -17549,22 +17765,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.
@@ -17595,106 +17803,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);
         },
     };
 
@@ -24899,36 +25015,235 @@
      */
     const DEFAULT_FEEDBACK_ERROR_MESSAGE = 'Failed to save feedback. Please try again.';
     /**
-     * Hook that centralizes rating state and handlers for Chat.
+     * Constant for feedback status timeout.
+     */
+    const FEEDBACK_STATUS_TIMEOUT_IN_MILLISECONDS = 3000;
+    /**
+     * Resolves the key used to keep one message rating in the local map.
      *
-     * @private component of `<Chat/>`
+     * @private function of `useChatRatings`
      */
-    function useChatRatings(options) {
-        const { messages, onFeedback, feedbackMode, feedbackTranslations, isMobile } = options;
+    function resolveChatRatingMessageKey$1(message) {
+        return message.id || message.content /* <- TODO: [??][??] Is `message.content` good replacement for the ID */;
+    }
+    /**
+     * Normalizes the stored rating for the current feedback mode.
+     *
+     * @private function of `useChatRatings`
+     */
+    function normalizeChatRatingValue(feedbackMode, rating) {
+        return feedbackMode === 'report_issue' ? 1 : rating;
+    }
+    /**
+     * Creates the next message-rating map with one updated message entry.
+     *
+     * @private function of `useChatRatings`
+     */
+    function createUpdatedMessageRatings(previousRatings, message, rating) {
+        const nextRatings = new Map(previousRatings);
+        nextRatings.set(resolveChatRatingMessageKey$1(message), rating);
+        return nextRatings;
+    }
+    /**
+     * Clears the transient feedback-status timeout when it is active.
+     *
+     * @private function of `useChatRatings`
+     */
+    function clearFeedbackStatusTimeout(feedbackStatusTimeoutRef) {
+        if (feedbackStatusTimeoutRef.current === null) {
+            return;
+        }
+        clearTimeout(feedbackStatusTimeoutRef.current);
+        feedbackStatusTimeoutRef.current = null;
+    }
+    /**
+     * Resolves the rating currently selected for the message being submitted.
+     *
+     * @private function of `useChatRatings`
+     */
+    function resolveSelectedMessageRating(params) {
+        const { feedbackMode, selectedMessage, messageRatings } = params;
+        const storedRating = messageRatings.get(resolveChatRatingMessageKey$1(selectedMessage));
+        if (feedbackMode === 'report_issue') {
+            return storedRating || 1;
+        }
+        return storedRating || null;
+    }
+    /**
+     * Serializes the current chat thread into the format expected by feedback handlers.
+     *
+     * @private function of `useChatRatings`
+     */
+    function createChatFeedbackThread(messages) {
+        return messages.map((message) => `${message.content}`).join('\n\n---\n\n');
+    }
+    /**
+     * Builds the payload submitted to the external feedback callback.
+     *
+     * @private function of `useChatRatings`
+     */
+    function createChatFeedbackSubmission(params) {
+        const { currentRating, messages, selectedMessage, textRating } = params;
+        return {
+            message: selectedMessage,
+            rating: currentRating,
+            textRating,
+            chatThread: createChatFeedbackThread(messages),
+            expectedAnswer: selectedMessage.expectedAnswer || selectedMessage.content || null,
+            url: window.location.href,
+        };
+    }
+    /**
+     * Resolves whether the current hook state is ready to submit feedback.
+     *
+     * @private function of `useChatRatings`
+     */
+    function prepareChatFeedbackSubmission(params) {
+        const { feedbackMode, messageRatings, messages, selectedMessage, textRating } = params;
+        if (!selectedMessage || feedbackMode === 'off') {
+            return null;
+        }
+        const currentRating = resolveSelectedMessageRating({
+            feedbackMode,
+            selectedMessage,
+            messageRatings,
+        });
+        if (!currentRating) {
+            return null;
+        }
+        return {
+            currentRating,
+            feedbackData: createChatFeedbackSubmission({
+                currentRating,
+                messages,
+                selectedMessage,
+                textRating,
+            }),
+        };
+    }
+    /**
+     * Resolves the success message shown after a rating or issue report is submitted.
+     *
+     * @private function of `useChatRatings`
+     */
+    function resolveChatFeedbackSuccessMessage(params) {
+        var _a, _b;
+        const { feedbackMode, feedbackTranslations, feedbackResponse } = params;
+        if (feedbackResponse === null || feedbackResponse === void 0 ? void 0 : feedbackResponse.message) {
+            return feedbackResponse.message;
+        }
+        if (feedbackMode === 'report_issue') {
+            return (_a = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.reportIssueSuccessMessage) !== null && _a !== void 0 ? _a : DEFAULT_REPORT_ISSUE_SUCCESS_MESSAGE;
+        }
+        return (_b = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackSuccessMessage) !== null && _b !== void 0 ? _b : DEFAULT_FEEDBACK_SUCCESS_MESSAGE;
+    }
+    /**
+     * Resolves the error message shown when feedback submission fails.
+     *
+     * @private function of `useChatRatings`
+     */
+    function resolveChatFeedbackErrorMessage(error, feedbackTranslations) {
+        var _a;
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return (_a = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackErrorMessage) !== null && _a !== void 0 ? _a : DEFAULT_FEEDBACK_ERROR_MESSAGE;
+    }
+    /**
+     * Logs the fallback feedback submission when no external handler is provided.
+     *
+     * @private function of `useChatRatings`
+     */
+    function logChatFeedbackSubmission(feedbackData) {
+        console.info('Rating submitted:', {
+            rating: '?'.repeat(feedbackData.rating),
+            textRating: feedbackData.textRating,
+            chatThread: feedbackData.chatThread,
+            expectedAnswer: feedbackData.expectedAnswer,
+            url: feedbackData.url,
+        });
+    }
+    /**
+     * Submits feedback through the external callback when present, otherwise logs it locally.
+     *
+     * @private function of `useChatRatings`
+     */
+    async function submitChatFeedback(params) {
+        const { feedbackData, feedbackMode, feedbackTranslations, onFeedback } = params;
+        const feedbackResponse = onFeedback ? await onFeedback(feedbackData) : undefined;
+        if (!onFeedback) {
+            logChatFeedbackSubmission(feedbackData);
+        }
+        return {
+            message: resolveChatFeedbackSuccessMessage({
+                feedbackMode,
+                feedbackTranslations,
+                feedbackResponse,
+            }),
+            variant: 'success',
+        };
+    }
+    /**
+     * Clears the rating modal state after a successful submission.
+     *
+     * @private function of `useChatRatings`
+     */
+    function resetChatRatingSubmissionState(params) {
+        const { setRatingModalOpen, setSelectedMessage, setTextRating } = params;
+        setRatingModalOpen(false);
+        setTextRating('');
+        setSelectedMessage(null);
+    }
+    /**
+     * Owns the mutable chat-rating state and the message-rating selection handler.
+     *
+     * @private internal hook of `useChatRatings`
+     */
+    function useChatRatingState(feedbackMode) {
         const [ratingModalOpen, setRatingModalOpen] = react.useState(false);
         const [selectedMessage, setSelectedMessage] = react.useState(null);
         const [messageRatings, setMessageRatings] = react.useState(new Map());
         const [textRating, setTextRating] = react.useState('');
         const [hoveredRating, setHoveredRating] = react.useState(0);
         const [expandedMessageId, setExpandedMessageId] = react.useState(null);
-        const [feedbackStatus, setFeedbackStatus] = react.useState(null);
-        const feedbackStatusTimeoutRef = react.useRef(null);
         const handleRating = react.useCallback((message, newRating) => {
-            const normalizedRating = feedbackMode === 'report_issue' ? 1 : newRating;
+            const normalizedRating = normalizeChatRatingValue(feedbackMode, newRating);
             setSelectedMessage(message);
             setMessageRatings((previousRatings) => {
-                const nextRatings = new Map(previousRatings);
-                nextRatings.set(message.id ||
-                    message.content /* <- TODO: [??][??] Is `message.content` good replacement for the ID */, normalizedRating);
-                return nextRatings;
+                return createUpdatedMessageRatings(previousRatings, message, normalizedRating);
             });
             setRatingModalOpen(true);
         }, [feedbackMode]);
+        return {
+            state: {
+                ratingModalOpen,
+                selectedMessage,
+                messageRatings,
+                textRating,
+                hoveredRating,
+                expandedMessageId,
+            },
+            actions: {
+                setRatingModalOpen,
+                setSelectedMessage,
+                setMessageRatings,
+                setTextRating,
+                setHoveredRating,
+                setExpandedMessageId,
+                handleRating,
+            },
+        };
+    }
+    /**
+     * Owns the transient feedback-status toast state and auto-hide lifecycle.
+     *
+     * @private internal hook of `useChatRatings`
+     */
+    function useChatFeedbackStatus() {
+        const [feedbackStatus, setFeedbackStatus] = react.useState(null);
+        const feedbackStatusTimeoutRef = react.useRef(null);
         const showFeedbackStatus = react.useCallback((status) => {
-            if (feedbackStatusTimeoutRef.current !== null) {
-                clearTimeout(feedbackStatusTimeoutRef.current);
-                feedbackStatusTimeoutRef.current = null;
-            }
+            clearFeedbackStatusTimeout(feedbackStatusTimeoutRef);
             setFeedbackStatus(status);
             if (!status || typeof window === 'undefined') {
                 return;
@@ -24936,111 +25251,122 @@
             feedbackStatusTimeoutRef.current = window.setTimeout(() => {
                 setFeedbackStatus(null);
                 feedbackStatusTimeoutRef.current = null;
-            }, 3000);
+            }, FEEDBACK_STATUS_TIMEOUT_IN_MILLISECONDS);
         }, []);
         react.useEffect(() => {
             return () => {
-                if (feedbackStatusTimeoutRef.current !== null) {
-                    clearTimeout(feedbackStatusTimeoutRef.current);
-                    feedbackStatusTimeoutRef.current = null;
-                }
+                clearFeedbackStatusTimeout(feedbackStatusTimeoutRef);
             };
         }, []);
-        const submitRating = react.useCallback(async () => {
-            var _a, _b, _c, _d, _e, _f;
-            if (!selectedMessage) {
-                return;
-            }
-            const selectedMessageId = selectedMessage.id || selectedMessage.content;
-            const storedRating = messageRatings.get(selectedMessageId);
-            const currentRating = feedbackMode === 'report_issue' ? storedRating || 1 : storedRating;
-            if (!currentRating || feedbackMode === 'off') {
+        return {
+            feedbackStatus,
+            showFeedbackStatus,
+        };
+    }
+    /**
+     * Builds the submit handler that validates, submits, reports status, and resets the modal.
+     *
+     * @private internal hook of `useChatRatings`
+     */
+    function useChatRatingSubmission(options) {
+        const { feedbackMode, feedbackTranslations, messageRatings, messages, onFeedback, selectedMessage, setRatingModalOpen, setSelectedMessage, setTextRating, showFeedbackStatus, textRating, } = options;
+        return react.useCallback(async () => {
+            const preparedSubmission = prepareChatFeedbackSubmission({
+                feedbackMode,
+                messageRatings,
+                messages,
+                selectedMessage,
+                textRating,
+            });
+            if (!preparedSubmission) {
                 return;
             }
-            const chatThread = messages.map((msg) => `${msg.content}`).join('\n\n---\n\n');
-            const feedbackData = {
-                message: selectedMessage,
-                rating: currentRating,
-                textRating: textRating,
-                chatThread,
-                expectedAnswer: selectedMessage.expectedAnswer || selectedMessage.content || null,
-                url: window.location.href,
-            };
-            if (onFeedback) {
-                try {
-                    const feedbackResponse = await onFeedback(feedbackData);
-                    showFeedbackStatus({
-                        message: (_a = feedbackResponse === null || feedbackResponse === void 0 ? void 0 : feedbackResponse.message) !== null && _a !== void 0 ? _a : (feedbackMode === 'report_issue'
-                            ? (_b = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.reportIssueSuccessMessage) !== null && _b !== void 0 ? _b : DEFAULT_REPORT_ISSUE_SUCCESS_MESSAGE
-                            : (_c = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackSuccessMessage) !== null && _c !== void 0 ? _c : DEFAULT_FEEDBACK_SUCCESS_MESSAGE),
-                        variant: 'success',
-                    });
-                }
-                catch (error) {
-                    console.error('Error submitting feedback:', error);
-                    const message = error instanceof Error
-                        ? error.message
-                        : (_d = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackErrorMessage) !== null && _d !== void 0 ? _d : DEFAULT_FEEDBACK_ERROR_MESSAGE;
-                    showFeedbackStatus({ message, variant: 'error' });
-                    return;
-                }
-            }
-            else {
-                console.info('Rating submitted:', {
-                    rating: '?'.repeat(currentRating),
-                    textRating: textRating,
-                    chatThread,
-                    expectedAnswer: selectedMessage.expectedAnswer || selectedMessage.content || null,
-                    url: window.location.href,
+            try {
+                const feedbackStatus = await submitChatFeedback({
+                    feedbackData: preparedSubmission.feedbackData,
+                    feedbackMode,
+                    feedbackTranslations,
+                    onFeedback,
                 });
+                showFeedbackStatus(feedbackStatus);
+            }
+            catch (error) {
+                console.error('Error submitting feedback:', error);
                 showFeedbackStatus({
-                    message: feedbackMode === 'report_issue'
-                        ? (_e = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.reportIssueSuccessMessage) !== null && _e !== void 0 ? _e : DEFAULT_REPORT_ISSUE_SUCCESS_MESSAGE
-                        : (_f = feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackSuccessMessage) !== null && _f !== void 0 ? _f : DEFAULT_FEEDBACK_SUCCESS_MESSAGE,
-                    variant: 'success',
+                    message: resolveChatFeedbackErrorMessage(error, feedbackTranslations),
+                    variant: 'error',
                 });
+                return;
             }
-            setRatingModalOpen(false);
-            setTextRating('');
-            setSelectedMessage(null);
+            resetChatRatingSubmissionState({
+                setRatingModalOpen,
+                setSelectedMessage,
+                setTextRating,
+            });
         }, [
             feedbackMode,
-            feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackErrorMessage,
-            feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.feedbackSuccessMessage,
-            feedbackTranslations === null || feedbackTranslations === void 0 ? void 0 : feedbackTranslations.reportIssueSuccessMessage,
-            messages,
+            feedbackTranslations,
             messageRatings,
+            messages,
             onFeedback,
             selectedMessage,
+            setRatingModalOpen,
+            setSelectedMessage,
+            setTextRating,
             showFeedbackStatus,
             textRating,
         ]);
+    }
+    /**
+     * Locks page scrolling while the rating modal is open on mobile layouts.
+     *
+     * @private internal hook of `useChatRatings`
+     */
+    function useChatRatingModalBodyScrollLock(params) {
+        const { isMobile, ratingModalOpen } = params;
         react.useEffect(() => {
-            if (ratingModalOpen && isMobile) {
-                document.body.style.overflow = 'hidden';
-                return () => {
-                    document.body.style.overflow = 'unset';
-                };
+            if (!(ratingModalOpen && isMobile)) {
+                return;
             }
-        }, [ratingModalOpen, isMobile]);
+            document.body.style.overflow = 'hidden';
+            return () => {
+                document.body.style.overflow = 'unset';
+            };
+        }, [isMobile, ratingModalOpen]);
+    }
+    /**
+     * Hook that centralizes rating state and handlers for Chat.
+     *
+     * @private component of `<Chat/>`
+     */
+    function useChatRatings(options) {
+        const { messages, onFeedback, feedbackMode, feedbackTranslations, isMobile } = options;
+        const { state, actions } = useChatRatingState(feedbackMode);
+        const { feedbackStatus, showFeedbackStatus } = useChatFeedbackStatus();
+        const submitRating = useChatRatingSubmission({
+            feedbackMode,
+            feedbackTranslations,
+            messageRatings: state.messageRatings,
+            messages,
+            onFeedback,
+            selectedMessage: state.selectedMessage,
+            setRatingModalOpen: actions.setRatingModalOpen,
+            setSelectedMessage: actions.setSelectedMessage,
+            setTextRating: actions.setTextRating,
+            showFeedbackStatus,
+            textRating: state.textRating,
+        });
+        useChatRatingModalBodyScrollLock({
+            isMobile,
+            ratingModalOpen: state.ratingModalOpen,
+        });
         return {
             state: {
-                ratingModalOpen,
-                selectedMessage,
-                messageRatings,
-                textRating,
-                hoveredRating,
-                expandedMessageId,
+                ...state,
                 feedbackStatus,
             },
             actions: {
-                setRatingModalOpen,
-                setSelectedMessage,
-                setMessageRatings,
-                setTextRating,
-                setHoveredRating,
-                setExpandedMessageId,
-                handleRating,
+                ...actions,
                 submitRating,
             },
         };
@@ -31719,43 +32045,21 @@
      * @private internal utility of `<Chat/>`
      */
     function resolveTimeoutToolCallPresentation(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
         const { toolCallName, args, resultRaw, locale } = options;
         if (!isTimeoutToolCallName$1(toolCallName)) {
             return null;
         }
-        const resultObject = resultRaw && typeof resultRaw === 'object' && !Array.isArray(resultRaw)
-            ? resultRaw
-            : null;
-        const defaultAction = toolCallName === 'cancel_timeout' ? 'cancel' : 'set';
-        const action = (resultObject === null || resultObject === void 0 ? void 0 : resultObject.action) === 'cancel' || (resultObject === null || resultObject === void 0 ? void 0 : resultObject.action) === 'set'
-            ? resultObject.action
-            : defaultAction;
-        const status = typeof (resultObject === null || resultObject === void 0 ? void 0 : resultObject.status) === 'string' ? resultObject.status : null;
-        const milliseconds = (_b = (_a = parsePositiveNumber(args.milliseconds)) !== null && _a !== void 0 ? _a : parsePositiveNumber(resultObject === null || resultObject === void 0 ? void 0 : resultObject.milliseconds)) !== null && _b !== void 0 ? _b : null;
-        const timeoutId = (_d = (_c = normalizeStringValue(resultObject === null || resultObject === void 0 ? void 0 : resultObject.timeoutId)) !== null && _c !== void 0 ? _c : normalizeStringValue(args.timeoutId)) !== null && _d !== void 0 ? _d : null;
-        const message = (_f = (_e = normalizeStringValue(args.message)) !== null && _e !== void 0 ? _e : normalizeStringValue(resultObject === null || resultObject === void 0 ? void 0 : resultObject.message)) !== null && _f !== void 0 ? _f : null;
-        const dueAtRaw = (_h = (_g = normalizeStringValue(resultObject === null || resultObject === void 0 ? void 0 : resultObject.dueAt)) !== null && _g !== void 0 ? _g : normalizeStringValue(args.dueAt)) !== null && _h !== void 0 ? _h : null;
-        const dueAtDate = dueAtRaw ? parseDateValue(dueAtRaw) : null;
-        const effectiveCurrentDate = options.currentDate || new Date();
-        const dueAtLabels = dueAtDate
-            ? formatToolCallDateTime(dueAtDate, { locale, currentDate: effectiveCurrentDate })
-            : null;
-        return {
-            action,
-            status,
-            milliseconds,
-            timeoutId,
-            message,
-            dueAtDate,
-            dueAtIsoUtc: dueAtDate ? dueAtDate.toISOString() : null,
-            localTimezone: resolveLocalTimezone(),
-            compactDurationLabel: milliseconds !== null ? formatTimeoutDurationCompact(milliseconds) : null,
-            humanDurationLabel: milliseconds !== null ? formatTimeoutDurationHuman(milliseconds) : null,
-            relativeDueLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.relativeTimeLabel) || null,
-            localDueTimeLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.localTimeLabel) || null,
-            localDueDateLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.localDateLabel) || null,
-        };
+        const timeoutToolCallCoreData = resolveTimeoutToolCallCoreData({
+            toolCallName,
+            args,
+            resultObject: resolveTimeoutToolCallResultObject(resultRaw),
+        });
+        const dueAtLabels = resolveTimeoutToolCallDueAtLabels({
+            dueAtDate: timeoutToolCallCoreData.dueAtDate,
+            currentDate: options.currentDate || new Date(),
+            locale,
+        });
+        return createTimeoutToolCallPresentation({ timeoutToolCallCoreData, dueAtLabels });
     }
     /**
      * Builds concise chip text for timeout tool calls.
@@ -31891,6 +32195,121 @@
     function formatTimeoutUnit(value, unit) {
         return `${value} ${unit}${value === 1 ? '' : 's'}`;
     }
+    /**
+     * Normalizes the raw timeout result payload when it is an object.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallResultObject(resultRaw) {
+        return resultRaw && typeof resultRaw === 'object' && !Array.isArray(resultRaw)
+            ? resultRaw
+            : null;
+    }
+    /**
+     * Resolves all timeout fields that depend only on arguments and raw result metadata.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallCoreData(options) {
+        const { toolCallName, args, resultObject } = options;
+        return {
+            action: resolveTimeoutToolCallAction(toolCallName, resultObject),
+            status: resolveTimeoutToolCallStatus(resultObject),
+            milliseconds: pickPositiveNumber(args.milliseconds, resultObject === null || resultObject === void 0 ? void 0 : resultObject.milliseconds),
+            timeoutId: pickNormalizedStringValue(resultObject === null || resultObject === void 0 ? void 0 : resultObject.timeoutId, args.timeoutId),
+            message: pickNormalizedStringValue(args.message, resultObject === null || resultObject === void 0 ? void 0 : resultObject.message),
+            dueAtDate: resolveTimeoutToolCallDueAtDate(args, resultObject),
+        };
+    }
+    /**
+     * Resolves the timeout action, preferring an explicit runtime result value.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallAction(toolCallName, resultObject) {
+        if ((resultObject === null || resultObject === void 0 ? void 0 : resultObject.action) === 'cancel' || (resultObject === null || resultObject === void 0 ? void 0 : resultObject.action) === 'set') {
+            return resultObject.action;
+        }
+        return toolCallName === 'cancel_timeout' ? 'cancel' : 'set';
+    }
+    /**
+     * Resolves the timeout status from the runtime result payload.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallStatus(resultObject) {
+        return typeof (resultObject === null || resultObject === void 0 ? void 0 : resultObject.status) === 'string' ? resultObject.status : null;
+    }
+    /**
+     * Resolves the scheduled due date, preferring the runtime result over input arguments.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallDueAtDate(args, resultObject) {
+        const dueAtRaw = pickNormalizedStringValue(resultObject === null || resultObject === void 0 ? void 0 : resultObject.dueAt, args.dueAt);
+        return dueAtRaw ? parseDateValue(dueAtRaw) : null;
+    }
+    /**
+     * Resolves localized due-date labels when a valid due date exists.
+     *
+     * @private internal timeout-chat helper
+     */
+    function resolveTimeoutToolCallDueAtLabels(options) {
+        const { dueAtDate, currentDate, locale } = options;
+        return dueAtDate ? formatToolCallDateTime(dueAtDate, { locale, currentDate }) : null;
+    }
+    /**
+     * Creates the final timeout presentation payload with derived labels.
+     *
+     * @private internal timeout-chat helper
+     */
+    function createTimeoutToolCallPresentation(options) {
+        const { timeoutToolCallCoreData, dueAtLabels } = options;
+        const { action, status, milliseconds, timeoutId, message, dueAtDate } = timeoutToolCallCoreData;
+        return {
+            action,
+            status,
+            milliseconds,
+            timeoutId,
+            message,
+            dueAtDate,
+            dueAtIsoUtc: dueAtDate ? dueAtDate.toISOString() : null,
+            localTimezone: resolveLocalTimezone(),
+            compactDurationLabel: milliseconds !== null ? formatTimeoutDurationCompact(milliseconds) : null,
+            humanDurationLabel: milliseconds !== null ? formatTimeoutDurationHuman(milliseconds) : null,
+            relativeDueLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.relativeTimeLabel) || null,
+            localDueTimeLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.localTimeLabel) || null,
+            localDueDateLabel: (dueAtLabels === null || dueAtLabels === void 0 ? void 0 : dueAtLabels.localDateLabel) || null,
+        };
+    }
+    /**
+     * Parses the first positive finite number from a prioritized list of values.
+     *
+     * @private internal timeout-chat helper
+     */
+    function pickPositiveNumber(...values) {
+        for (const value of values) {
+            const positiveNumber = parsePositiveNumber(value);
+            if (positiveNumber !== null) {
+                return positiveNumber;
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolves the first non-empty trimmed string from a prioritized list of values.
+     *
+     * @private internal timeout-chat helper
+     */
+    function pickNormalizedStringValue(...values) {
+        for (const value of values) {
+            const normalizedStringValue = normalizeStringValue(value);
+            if (normalizedStringValue !== null) {
+                return normalizedStringValue;
+            }
+        }
+        return null;
+    }
     /**
      * Parses date-like values into a valid `Date`.
      *
@@ -32231,6 +32650,39 @@
      * Length of memory chip truncate.
      */
     const MEMORY_CHIP_TRUNCATE_LENGTH = 45;
+    /**
+     * Tool names that render a localized current-time chip.
+     *
+     * @private utility of `<Chat/>`
+     */
+    const TIME_TOOL_CALL_NAMES = new Set(['get_current_time', 'useTime']);
+    /**
+     * Tool names that render the email subject when available.
+     *
+     * @private utility of `<Chat/>`
+     */
+    const EMAIL_TOOL_CALL_NAMES = new Set(['send_email', 'useEmail']);
+    /**
+     * Tool names that render a memory preview.
+     *
+     * @private utility of `<Chat/>`
+     */
+    const MEMORY_TOOL_CALL_NAMES = new Set(['retrieve_user_memory', 'store_user_memory']);
+    /**
+     * Ordered specialized chiplet resolvers evaluated before the generic fallback.
+     *
+     * @private utility of `<Chat/>`
+     */
+    const SPECIALIZED_TOOL_CALL_CHIPLET_RESOLVERS = [
+        resolveWalletCredentialChipletInfo,
+        resolveTeamToolCallChipletInfo,
+        resolveTimeToolCallChipletInfo,
+        resolveEmailToolCallChipletInfo,
+        resolveMemoryToolCallChipletInfo,
+        resolveTimeoutToolCallChipletInfo,
+        resolveQueryToolCallChipletInfo,
+        resolveUrlToolCallChipletInfo,
+    ];
     /**
      * Builds display text for a tool call chiplet.
      *
@@ -32294,96 +32746,310 @@
      * @private [🧠] Maybe public?
      */
     function getToolCallChipletInfo(toolCall, locale, titleOverrides, chipTranslations) {
-        const toolInfo = TOOL_TITLES[toolCall.name];
-        const baseTitle = (titleOverrides === null || titleOverrides === void 0 ? void 0 : titleOverrides[toolCall.name]) || (toolInfo === null || toolInfo === void 0 ? void 0 : toolInfo.title) || toolCall.name;
-        const emoji = (toolInfo === null || toolInfo === void 0 ? void 0 : toolInfo.emoji) || '🛠️';
+        const context = createToolCallChipletContext(toolCall, locale, titleOverrides, chipTranslations);
+        return resolveSpecializedToolCallChipletInfo(context) || createDefaultToolCallChipletInfo(context);
+    }
+    /**
+     * Collects the parsed values shared by all chiplet resolution steps.
+     *
+     * @param toolCall - Tool call being rendered.
+     * @param locale - Optional locale used by time-sensitive helpers.
+     * @param titleOverrides - Optional localized title overrides.
+     * @param chipTranslations - Optional localized chip templates reused by specialized resolvers.
+     * @returns Shared chiplet resolution context.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function createToolCallChipletContext(toolCall, locale, titleOverrides, chipTranslations) {
         const args = parseToolCallArguments(toolCall);
-        const isTimeTool = toolCall.name === 'get_current_time' || toolCall.name === 'useTime';
-        const isEmailTool = toolCall.name === 'send_email' || toolCall.name === 'useEmail';
-        const isMemoryTool = toolCall.name === 'retrieve_user_memory' || toolCall.name === 'store_user_memory';
-        const isTimeoutTool = toolCall.name === 'set_timeout' || toolCall.name === 'cancel_timeout';
         const resultRaw = parseToolCallResult(toolCall.result);
-        const timeoutPresentation = isTimeoutTool
-            ? resolveTimeoutToolCallPresentation({
-                toolCallName: toolCall.name,
-                args,
-                resultRaw,
-                currentDate: new Date(),
-                locale,
-            })
-            : null;
-        const walletCredentialResult = parseWalletCredentialToolCallResult(resultRaw);
-        const teamResult = parseTeamToolResult(resultRaw);
-        if (walletCredentialResult) {
-            return {
-                text: `${emoji} ${walletCredentialResult.credentialName}`,
-            };
+        return {
+            toolCall,
+            locale,
+            chipTranslations,
+            args,
+            resultRaw,
+            baseTitle: resolveToolCallBaseTitle(toolCall.name, titleOverrides),
+            emoji: resolveToolCallEmoji(toolCall.name),
+            timeoutPresentation: resolveToolCallChipletTimeoutPresentation(toolCall.name, args, resultRaw, locale),
+        };
+    }
+    /**
+     * Resolves the first specialized chiplet branch that matches the tool call.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Specialized chiplet info when any resolver matches, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveSpecializedToolCallChipletInfo(context) {
+        for (const resolveToolCallChipletInfo of SPECIALIZED_TOOL_CALL_CHIPLET_RESOLVERS) {
+            const chipletInfo = resolveToolCallChipletInfo(context);
+            if (chipletInfo) {
+                return chipletInfo;
+            }
         }
-        if (teamResult === null || teamResult === void 0 ? void 0 : teamResult.teammate) {
-            const label = teamResult.teammate.label || teamResult.teammate.url || baseTitle;
-            const agentData = {
-                url: teamResult.teammate.url,
-                label,
-            };
-            return {
-                text: label,
-                agentData,
-            };
+        return null;
+    }
+    /**
+     * Resolves the human-friendly fallback title for one tool call.
+     *
+     * @param toolName - Raw tool name.
+     * @param titleOverrides - Optional localized title overrides.
+     * @returns Title used when no specialized chip label applies.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveToolCallBaseTitle(toolName, titleOverrides) {
+        var _a;
+        return (titleOverrides === null || titleOverrides === void 0 ? void 0 : titleOverrides[toolName]) || ((_a = TOOL_TITLES[toolName]) === null || _a === void 0 ? void 0 : _a.title) || toolName;
+    }
+    /**
+     * Resolves the emoji prefix used by standard tool chips.
+     *
+     * @param toolName - Raw tool name.
+     * @returns Emoji shown at the beginning of the chip.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveToolCallEmoji(toolName) {
+        var _a;
+        return ((_a = TOOL_TITLES[toolName]) === null || _a === void 0 ? void 0 : _a.emoji) || '🛠️';
+    }
+    /**
+     * Resolves timeout presentation metadata only for timeout-aware tools.
+     *
+     * @param toolName - Raw tool name.
+     * @param args - Parsed tool arguments.
+     * @param resultRaw - Parsed tool result payload.
+     * @param locale - Optional locale used for friendly date formatting.
+     * @returns Timeout presentation metadata or `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveToolCallChipletTimeoutPresentation(toolName, args, resultRaw, locale) {
+        if (!isTimeoutToolCallName$1(toolName)) {
+            return null;
         }
-        if (isTimeTool) {
-            const resultDate = getToolCallResultDate(resultRaw);
-            if (resultDate) {
-                return {
-                    text: `${emoji} ${formatToolCallTranslationTemplate((chipTranslations === null || chipTranslations === void 0 ? void 0 : chipTranslations.toolCallTimeChipLabel) || '{time}', {
-                    time: formatToolCallLocalTime(resultDate, locale),
-                })}`,
-                };
-            }
+        return resolveTimeoutToolCallPresentation({
+            toolCallName: toolName,
+            args,
+            resultRaw,
+            currentDate: new Date(),
+            locale,
+        });
+    }
+    /**
+     * Resolves a chip label for synthetic wallet-credential tool calls.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when the tool result represents wallet credentials, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveWalletCredentialChipletInfo(context) {
+        const walletCredentialResult = parseWalletCredentialToolCallResult(context.resultRaw);
+        if (!walletCredentialResult) {
+            return null;
         }
-        if (isEmailTool) {
-            if (args.subject) {
-                return {
-                    text: `${emoji} ${args.subject}`,
-                };
-            }
+        return createEmojiToolCallChipletInfo(context, walletCredentialResult.credentialName);
+    }
+    /**
+     * Resolves a chip label and agent metadata for TEAM tool calls.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when the result contains teammate metadata, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveTeamToolCallChipletInfo(context) {
+        const teamResult = parseTeamToolResult(context.resultRaw);
+        if (!(teamResult === null || teamResult === void 0 ? void 0 : teamResult.teammate)) {
+            return null;
         }
-        if (isMemoryTool) {
-            const memoryPreview = getMemoryPreviewText(args, resultRaw);
-            if (memoryPreview) {
-                return {
-                    text: `${emoji} ${memoryPreview}`,
-                };
-            }
+        const label = teamResult.teammate.label || teamResult.teammate.url || context.baseTitle;
+        const agentData = {
+            url: teamResult.teammate.url,
+            label,
+        };
+        return {
+            text: label,
+            agentData,
+        };
+    }
+    /**
+     * Resolves the specialized time chip label when the tool returns a valid date.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when a time label can be built, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveTimeToolCallChipletInfo(context) {
+        var _a;
+        if (!isTimeToolCallName$1(context.toolCall.name)) {
+            return null;
         }
-        if (isTimeoutTool && timeoutPresentation) {
-            return {
-                text: `${emoji} ${buildTimeoutToolCallChipLabel(timeoutPresentation, chipTranslations)}`,
-            };
+        const resultDate = getToolCallResultDate(context.resultRaw);
+        if (!resultDate) {
+            return null;
         }
-        if (args.query) {
-            return {
-                text: `${emoji} ${args.query}`,
-            };
+        return createEmojiToolCallChipletInfo(context, formatToolCallTranslationTemplate(((_a = context.chipTranslations) === null || _a === void 0 ? void 0 : _a.toolCallTimeChipLabel) || '{time}', {
+            time: formatToolCallLocalTime(resultDate, context.locale),
+        }));
+    }
+    /**
+     * Resolves the email-subject chip label when a subject is present.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when the email subject can be shown, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveEmailToolCallChipletInfo(context) {
+        if (!isEmailToolCallName$1(context.toolCall.name) || typeof context.args.subject !== 'string') {
+            return null;
         }
-        if (args.url) {
-            try {
-                const url = new URL(args.url);
-                return {
-                    text: `${emoji} ${url.hostname}`,
-                };
-            }
-            catch (e) {
-                return {
-                    text: `${emoji} ${args.url}`,
-                };
-            }
+        return createEmojiToolCallChipletInfo(context, context.args.subject);
+    }
+    /**
+     * Resolves the memory-preview chip label for MEMORY tools.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when a memory preview is available, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveMemoryToolCallChipletInfo(context) {
+        if (!isMemoryToolCallName(context.toolCall.name)) {
+            return null;
+        }
+        const memoryPreview = getMemoryPreviewText(context.args, context.resultRaw);
+        if (!memoryPreview) {
+            return null;
         }
+        return createEmojiToolCallChipletInfo(context, memoryPreview);
+    }
+    /**
+     * Resolves the timeout-specific chip label when timeout presentation metadata is available.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when the tool is a timeout tool, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveTimeoutToolCallChipletInfo(context) {
+        if (!context.timeoutPresentation) {
+            return null;
+        }
+        return createEmojiToolCallChipletInfo(context, buildTimeoutToolCallChipLabel(context.timeoutPresentation, context.chipTranslations));
+    }
+    /**
+     * Resolves a query-based chip label used by search-like tools.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when a query string is present, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveQueryToolCallChipletInfo(context) {
+        if (typeof context.args.query !== 'string') {
+            return null;
+        }
+        return createEmojiToolCallChipletInfo(context, context.args.query);
+    }
+    /**
+     * Resolves a URL-based chip label by preferring the hostname over the raw URL.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Chiplet info when a URL string is present, otherwise `null`.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveUrlToolCallChipletInfo(context) {
+        if (typeof context.args.url !== 'string') {
+            return null;
+        }
+        return createEmojiToolCallChipletInfo(context, resolveUrlChipLabel(context.args.url));
+    }
+    /**
+     * Builds the final fallback chip label when no specialized branch matches.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @returns Fallback chiplet info.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function createDefaultToolCallChipletInfo(context) {
+        return createEmojiToolCallChipletInfo(context, context.baseTitle);
+    }
+    /**
+     * Builds a standard emoji-prefixed chip info object.
+     *
+     * @param context - Shared chiplet resolution context.
+     * @param label - User-facing chip label without emoji prefix.
+     * @returns Emoji-prefixed chiplet info.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function createEmojiToolCallChipletInfo(context, label) {
         return {
-            text: `${emoji} ${baseTitle}`,
+            text: `${context.emoji} ${label}`,
         };
     }
+    /**
+     * Resolves a friendly URL chip label, preferring the hostname over the raw input.
+     *
+     * @param rawUrl - Raw URL argument value.
+     * @returns Hostname when URL parsing succeeds, otherwise the original string.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function resolveUrlChipLabel(rawUrl) {
+        try {
+            return new URL(rawUrl).hostname;
+        }
+        catch (_a) {
+            return rawUrl;
+        }
+    }
+    /**
+     * Checks whether a tool name belongs to the time commitment.
+     *
+     * @param toolName - Raw tool name.
+     * @returns `true` when the chip should show a localized time label.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function isTimeToolCallName$1(toolName) {
+        return TIME_TOOL_CALL_NAMES.has(toolName);
+    }
+    /**
+     * Checks whether a tool name belongs to the email commitment.
+     *
+     * @param toolName - Raw tool name.
+     * @returns `true` when the chip may show an email subject.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function isEmailToolCallName$1(toolName) {
+        return EMAIL_TOOL_CALL_NAMES.has(toolName);
+    }
+    /**
+     * Checks whether a tool name belongs to the memory commitment.
+     *
+     * @param toolName - Raw tool name.
+     * @returns `true` when the chip may show a memory preview.
+     *
+     * @private utility of `<Chat/>`
+     */
+    function isMemoryToolCallName(toolName) {
+        return MEMORY_TOOL_CALL_NAMES.has(toolName);
+    }
     /**
      * Builds memory preview text for MEMORY commitment tool calls.
+     *
+     * @private utility of `<Chat/>`
      */
     function getMemoryPreviewText(args, resultRaw) {
         var _a, _b, _c;
@@ -32406,6 +33072,8 @@
     }
     /**
      * Shortens long memory content for compact chip display.
+     *
+     * @private utility of `<Chat/>`
      */
     function shortenMemoryPreview(content) {
         const trimmed = content.trim().replace(/\s+/g, ' ');
@@ -55449,26 +56117,13 @@
     styleInject(css_248z);
 
     /**
-     * Renders a floating agent button that opens a chat window with the remote agent.
+     * Handles controlled/uncontrolled open state for the widget.
      *
-     * @private component of PromptbookAgentIntegration
+     * @private internal hook of PromptbookAgentSeamlessIntegration
      */
-    function PromptbookAgentSeamlessIntegration(props) {
-        var _a, _b;
-        const { agentUrl, meta, onOpenChange, isOpen: controlledIsOpen, defaultOpen = false, className, style, isFocusedOnLoad, isIframeUsed = false, } = props;
+    function usePromptbookAgentSeamlessIntegrationOpenState({ agentUrl, defaultOpen = false, isOpen: controlledIsOpen, onOpenChange, }) {
         const [internalIsOpen, setInternalIsOpen] = react.useState(defaultOpen);
-        const [headerElement, setHeaderElement] = react.useState(null);
-        const [isIframeLoaded, setIsIframeLoaded] = react.useState(false);
-        const [isChatConnected, setIsChatConnected] = react.useState(false);
-        const rootElementRef = react.useRef(null);
-        const windowId = react.useId();
         const isOpen = controlledIsOpen !== null && controlledIsOpen !== void 0 ? controlledIsOpen : internalIsOpen;
-        /**
-         * Updates the widget open state and notifies integration callbacks.
-         *
-         * @param nextIsOpen - Target open state.
-         * @private internal utility of PromptbookAgentSeamlessIntegration
-         */
         const setOpen = react.useCallback((nextIsOpen) => {
             if (controlledIsOpen === undefined) {
                 setInternalIsOpen(nextIsOpen);
@@ -55481,22 +56136,21 @@
             }
             setInternalIsOpen(defaultOpen);
         }, [agentUrl, controlledIsOpen, defaultOpen]);
-        react.useEffect(() => {
-            if (!isOpen) {
-                setIsIframeLoaded(false);
-            }
-        }, [isOpen]);
-        react.useEffect(() => {
-            setIsIframeLoaded(false);
-            setIsChatConnected(false);
-        }, [agentUrl]);
+        return { isOpen, setOpen };
+    }
+    /**
+     * Closes the widget when the user presses Escape or clicks outside.
+     *
+     * @private internal hook of PromptbookAgentSeamlessIntegration
+     */
+    function useClosePromptbookAgentSeamlessIntegrationOnOutsideInteraction({ isOpen, rootElementRef, onClose, }) {
         react.useEffect(() => {
             if (!isOpen) {
                 return;
             }
             const handleKeyDown = (event) => {
                 if (event.key === 'Escape') {
-                    setOpen(false);
+                    onClose();
                 }
             };
             const handlePointerDown = (event) => {
@@ -55508,7 +56162,7 @@
                 if (target instanceof Node && rootElement.contains(target)) {
                     return;
                 }
-                setOpen(false);
+                onClose();
             };
             window.addEventListener('keydown', handleKeyDown);
             window.addEventListener('pointerdown', handlePointerDown);
@@ -55516,23 +56170,22 @@
                 window.removeEventListener('keydown', handleKeyDown);
                 window.removeEventListener('pointerdown', handlePointerDown);
             };
-        }, [isOpen, setOpen]);
+        }, [isOpen, onClose, rootElementRef]);
+    }
+    /**
+     * Connects to the remote agent and tracks the connection lifecycle.
+     *
+     * @private internal hook of PromptbookAgentSeamlessIntegration
+     */
+    function useRemotePromptbookAgent(agentUrl) {
         const [agent, setAgent] = react.useState(null);
         const [error, setError] = react.useState(null);
-        react.useEffect(() => {
-            if (agent && meta) {
-                if (agent.meta.image && meta.image && agent.meta.image !== meta.image) {
-                    console.warn('Conflict in agent meta image:', { server: agent.meta.image, props: meta.image });
-                }
-                if (agent.meta.color && meta.color && agent.meta.color !== meta.color) {
-                    console.warn('Conflict in agent meta color:', { server: agent.meta.color, props: meta.color });
-                }
-            }
-        }, [agent, meta]);
+        const [isAgentConnected, setIsAgentConnected] = react.useState(false);
         react.useEffect(() => {
             let isMounted = true;
             setAgent(null);
             setError(null);
+            setIsAgentConnected(false);
             const connectToAgent = async () => {
                 try {
                     // TODO: [🧠] Maybe we should not connect immediately but only when the user clicks the button or hovers?
@@ -55540,7 +56193,7 @@
                     const connectedAgent = await RemoteAgent.connect({ agentUrl });
                     if (isMounted) {
                         setAgent(connectedAgent);
-                        setIsChatConnected(true);
+                        setIsAgentConnected(true);
                     }
                 }
                 catch (err) {
@@ -55555,30 +56208,169 @@
                 isMounted = false;
             };
         }, [agentUrl]);
-        // TODO: [🧠] Handle loading state better (show spinner or skeleton in the chat window)
-        // TODO: [🧠] Handle error state (show error message in the chat window)
-        const image = ((_a = agent === null || agent === void 0 ? void 0 : agent.meta) === null || _a === void 0 ? void 0 : _a.image) ||
-            (meta === null || meta === void 0 ? void 0 : meta.image) ||
-            // Note: [🤹] Using default avatar from the agent server
-            `${agentUrl}/images/default-avatar.png`;
-        const color = ((_b = agent === null || agent === void 0 ? void 0 : agent.meta) === null || _b === void 0 ? void 0 : _b.color) || (meta === null || meta === void 0 ? void 0 : meta.color);
-        const displayName = (agent === null || agent === void 0 ? void 0 : agent.meta.fullname) || (meta === null || meta === void 0 ? void 0 : meta.fullname) || (agent === null || agent === void 0 ? void 0 : agent.agentName) || 'Chat with Agent';
+        return { agent, error, isAgentConnected };
+    }
+    /**
+     * Warns when props branding conflicts with the branding returned by the server.
+     *
+     * @private internal hook of PromptbookAgentSeamlessIntegration
+     */
+    function useWarnAboutPromptbookAgentMetaConflicts(agent, meta) {
+        react.useEffect(() => {
+            if (!agent || !meta) {
+                return;
+            }
+            if (agent.meta.image && meta.image && agent.meta.image !== meta.image) {
+                console.warn('Conflict in agent meta image:', { server: agent.meta.image, props: meta.image });
+            }
+            if (agent.meta.color && meta.color && agent.meta.color !== meta.color) {
+                console.warn('Conflict in agent meta color:', { server: agent.meta.color, props: meta.color });
+            }
+        }, [agent, meta]);
+    }
+    /**
+     * Resolves the avatar, color, and display name shown by the widget.
+     *
+     * @private internal utility of PromptbookAgentSeamlessIntegration
+     */
+    function resolvePromptbookAgentSeamlessIntegrationDisplayInfo({ agent, agentUrl, meta, }) {
+        var _a, _b;
+        return {
+            image: ((_a = agent === null || agent === void 0 ? void 0 : agent.meta) === null || _a === void 0 ? void 0 : _a.image) ||
+                (meta === null || meta === void 0 ? void 0 : meta.image) ||
+                // Note: [🤹] Using default avatar from the agent server
+                `${agentUrl}/images/default-avatar.png`,
+            color: ((_b = agent === null || agent === void 0 ? void 0 : agent.meta) === null || _b === void 0 ? void 0 : _b.color) || (meta === null || meta === void 0 ? void 0 : meta.color),
+            displayName: (agent === null || agent === void 0 ? void 0 : agent.meta.fullname) || (meta === null || meta === void 0 ? void 0 : meta.fullname) || (agent === null || agent === void 0 ? void 0 : agent.agentName) || 'Chat with Agent',
+        };
+    }
+    /**
+     * Resolves the connection status label and indicator class.
+     *
+     * @private internal utility of PromptbookAgentSeamlessIntegration
+     */
+    function createPromptbookAgentSeamlessIntegrationConnectionPresentation({ isConnected, error, isIframeUsed, }) {
         let connectionStatus = 'pending';
-        if (isChatConnected || agent) {
+        if (isConnected) {
             connectionStatus = 'connected';
         }
         else if (error && !isIframeUsed) {
             connectionStatus = 'error';
         }
-        const connectionStatusText = connectionStatus === 'connected' ? 'Online' : connectionStatus === 'error' ? 'Connection issue' : 'Connecting';
-        return (jsxRuntime.jsxs("div", { className: classNames(`${styles.PromptbookAgentSeamlessIntegration} ${isOpen ? styles.open : styles.closed}`, className), style: style, ref: rootElementRef, children: [jsxRuntime.jsxs("button", { type: "button", className: styles.PromptbookAgentSeamlessIntegrationButton, onClick: () => setOpen(!isOpen), style: { backgroundColor: color }, "aria-expanded": isOpen, "aria-controls": windowId, title: isOpen ? `Close chat with ${displayName}` : `Open chat with ${displayName}`, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationAvatar, children: jsxRuntime.jsx("img", { src: image, alt: `${displayName} avatar` }) }), jsxRuntime.jsx("div", { className: classNames(styles.PromptbookAgentSeamlessIntegrationStatus, connectionStatus === 'connected'
-                                ? styles.PromptbookAgentSeamlessIntegrationStatusConnected
-                                : connectionStatus === 'error'
-                                    ? styles.PromptbookAgentSeamlessIntegrationStatusError
-                                    : styles.PromptbookAgentSeamlessIntegrationStatusPending) }), jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationText, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLabel, children: "Chat" }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationHint, children: displayName })] }), jsxRuntime.jsx("span", { className: styles.PromptbookAgentSeamlessIntegrationScreenReaderOnly, children: connectionStatusText })] }), isOpen && (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationWindow, id: windowId, children: [jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationHeader, style: { backgroundColor: color }, ref: setHeaderElement, children: [jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationTitleWrap, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationTitle, children: displayName }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationSubtitle, children: connectionStatusText })] }), isIframeUsed && (jsxRuntime.jsx("button", { className: styles.PromptbookAgentSeamlessIntegrationClose, onClick: () => setOpen(false), title: "Close", "aria-label": "Close chat", children: jsxRuntime.jsx(CloseIcon, {}) }))] }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationContent, children: isIframeUsed ? (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [!isIframeLoaded && (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoading, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingShimmer }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingSpinner }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingTitle, children: "Preparing your chat" }), jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingText, children: ["Connecting to ", displayName, "..."] })] })), jsxRuntime.jsx("iframe", { src: agentUrl + '/chat?headless', className: styles.PromptbookAgentSeamlessIntegrationIframe, style: { opacity: isIframeLoaded ? 1 : 0 }, tabIndex: -1, onLoad: () => {
-                                            setIsIframeLoaded(true);
-                                            setIsChatConnected(true);
-                                        } })] })) : agent ? (jsxRuntime.jsx(AgentChat, { agent: agent, actionsContainer: headerElement, isFocusedOnLoad: isFocusedOnLoad, extraActions: jsxRuntime.jsx("button", { className: styles.PromptbookAgentSeamlessIntegrationClose, onClick: () => setOpen(false), title: "Close", "aria-label": "Close chat", children: jsxRuntime.jsx(CloseIcon, {}) }), layout: "STANDALONE" })) : error ? (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationError, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationErrorTitle, children: "Failed to connect to the agent" }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationErrorMessage, children: error.message })] })) : (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoading, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingShimmer }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingSpinner }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingTitle, children: "Preparing your chat" }), jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingText, children: ["Connecting to ", displayName, "..."] })] })) })] }))] }));
+        return {
+            connectionStatus,
+            connectionStatusText: connectionStatus === 'connected'
+                ? 'Online'
+                : connectionStatus === 'error'
+                    ? 'Connection issue'
+                    : 'Connecting',
+            connectionStatusClassName: getPromptbookAgentSeamlessIntegrationStatusClassName(connectionStatus),
+        };
+    }
+    /**
+     * Resolves the CSS class for the connection status indicator.
+     *
+     * @private internal utility of PromptbookAgentSeamlessIntegration
+     */
+    function getPromptbookAgentSeamlessIntegrationStatusClassName(connectionStatus) {
+        if (connectionStatus === 'connected') {
+            return styles.PromptbookAgentSeamlessIntegrationStatusConnected;
+        }
+        if (connectionStatus === 'error') {
+            return styles.PromptbookAgentSeamlessIntegrationStatusError;
+        }
+        return styles.PromptbookAgentSeamlessIntegrationStatusPending;
+    }
+    /**
+     * Renders the shared close button used by the widget.
+     *
+     * @private internal subcomponent of PromptbookAgentSeamlessIntegration
+     */
+    function PromptbookAgentSeamlessIntegrationCloseButton({ onClose, }) {
+        return (jsxRuntime.jsx("button", { className: styles.PromptbookAgentSeamlessIntegrationClose, onClick: onClose, title: "Close", "aria-label": "Close chat", children: jsxRuntime.jsx(CloseIcon, {}) }));
+    }
+    /**
+     * Renders the loading state shared by iframe and embedded chat modes.
+     *
+     * @private internal subcomponent of PromptbookAgentSeamlessIntegration
+     */
+    function PromptbookAgentSeamlessIntegrationLoadingState({ displayName, }) {
+        return (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoading, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingShimmer }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingSpinner }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingTitle, children: "Preparing your chat" }), jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationLoadingText, children: ["Connecting to ", displayName, "..."] })] }));
+    }
+    /**
+     * Renders the inline error state for direct chat mode.
+     *
+     * @private internal subcomponent of PromptbookAgentSeamlessIntegration
+     */
+    function PromptbookAgentSeamlessIntegrationErrorState({ error }) {
+        return (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationError, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationErrorTitle, children: "Failed to connect to the agent" }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationErrorMessage, children: error.message })] }));
+    }
+    /**
+     * Renders the main content area based on the selected integration mode.
+     *
+     * @private internal subcomponent of PromptbookAgentSeamlessIntegration
+     */
+    function PromptbookAgentSeamlessIntegrationContent({ agent, agentUrl, displayName, error, headerElement, isFocusedOnLoad, isIframeLoaded, isIframeUsed, onClose, onIframeLoad, }) {
+        if (isIframeUsed) {
+            return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [!isIframeLoaded && jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationLoadingState, { displayName: displayName }), jsxRuntime.jsx("iframe", { src: agentUrl + '/chat?headless', className: styles.PromptbookAgentSeamlessIntegrationIframe, style: { opacity: isIframeLoaded ? 1 : 0 }, tabIndex: -1, onLoad: onIframeLoad })] }));
+        }
+        if (agent) {
+            return (jsxRuntime.jsx(AgentChat, { agent: agent, actionsContainer: headerElement, isFocusedOnLoad: isFocusedOnLoad, extraActions: jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationCloseButton, { onClose: onClose }), layout: "STANDALONE" }));
+        }
+        if (error) {
+            return jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationErrorState, { error: error });
+        }
+        return jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationLoadingState, { displayName: displayName });
+    }
+    /**
+     * Renders a floating agent button that opens a chat window with the remote agent.
+     *
+     * @private component of PromptbookAgentIntegration
+     */
+    function PromptbookAgentSeamlessIntegration(props) {
+        const { agentUrl, meta, className, style, isFocusedOnLoad, isIframeUsed = false } = props;
+        const [headerElement, setHeaderElement] = react.useState(null);
+        const [isIframeLoaded, setIsIframeLoaded] = react.useState(false);
+        const rootElementRef = react.useRef(null);
+        const windowId = react.useId();
+        const { isOpen, setOpen } = usePromptbookAgentSeamlessIntegrationOpenState(props);
+        const { agent, error, isAgentConnected } = useRemotePromptbookAgent(agentUrl);
+        const handleClose = react.useCallback(() => {
+            setOpen(false);
+        }, [setOpen]);
+        const handleToggle = react.useCallback(() => {
+            setOpen(!isOpen);
+        }, [isOpen, setOpen]);
+        const handleIframeLoad = react.useCallback(() => {
+            setIsIframeLoaded(true);
+        }, []);
+        react.useEffect(() => {
+            if (!isOpen) {
+                setIsIframeLoaded(false);
+            }
+        }, [isOpen]);
+        react.useEffect(() => {
+            setIsIframeLoaded(false);
+        }, [agentUrl]);
+        useClosePromptbookAgentSeamlessIntegrationOnOutsideInteraction({
+            isOpen,
+            rootElementRef,
+            onClose: handleClose,
+        });
+        useWarnAboutPromptbookAgentMetaConflicts(agent, meta);
+        // TODO: [🧠] Handle loading state better (show spinner or skeleton in the chat window)
+        // TODO: [🧠] Handle error state (show error message in the chat window)
+        const { image, color, displayName } = resolvePromptbookAgentSeamlessIntegrationDisplayInfo({
+            agent,
+            agentUrl,
+            meta,
+        });
+        const { connectionStatusText, connectionStatusClassName } = createPromptbookAgentSeamlessIntegrationConnectionPresentation({
+            isConnected: isAgentConnected || isIframeLoaded,
+            error,
+            isIframeUsed,
+        });
+        return (jsxRuntime.jsxs("div", { className: classNames(`${styles.PromptbookAgentSeamlessIntegration} ${isOpen ? styles.open : styles.closed}`, className), style: style, ref: rootElementRef, children: [jsxRuntime.jsxs("button", { type: "button", className: styles.PromptbookAgentSeamlessIntegrationButton, onClick: handleToggle, style: { backgroundColor: color }, "aria-expanded": isOpen, "aria-controls": windowId, title: isOpen ? `Close chat with ${displayName}` : `Open chat with ${displayName}`, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationAvatar, children: jsxRuntime.jsx("img", { src: image, alt: `${displayName} avatar` }) }), jsxRuntime.jsx("div", { className: classNames(styles.PromptbookAgentSeamlessIntegrationStatus, connectionStatusClassName) }), jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationText, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationLabel, children: "Chat" }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationHint, children: displayName })] }), jsxRuntime.jsx("span", { className: styles.PromptbookAgentSeamlessIntegrationScreenReaderOnly, children: connectionStatusText })] }), isOpen && (jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationWindow, id: windowId, children: [jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationHeader, style: { backgroundColor: color }, ref: setHeaderElement, children: [jsxRuntime.jsxs("div", { className: styles.PromptbookAgentSeamlessIntegrationTitleWrap, children: [jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationTitle, children: displayName }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationSubtitle, children: connectionStatusText })] }), isIframeUsed && jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationCloseButton, { onClose: handleClose })] }), jsxRuntime.jsx("div", { className: styles.PromptbookAgentSeamlessIntegrationContent, children: jsxRuntime.jsx(PromptbookAgentSeamlessIntegrationContent, { agent: agent, agentUrl: agentUrl, displayName: displayName, error: error, headerElement: headerElement, isFocusedOnLoad: isFocusedOnLoad, isIframeLoaded: isIframeLoaded, isIframeUsed: isIframeUsed, onClose: handleClose, onIframeLoad: handleIframeLoad }) })] }))] }));
     }
 
     /**