react-instantsearch 7.45.0 → 7.47.0

package/dist/umd/ReactInstantSearch.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch 7.45.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch 7.47.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
     typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
@@ -24,7 +24,7 @@
 
     var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
-    var version$2 = '7.45.0';
+    var version$2 = '7.47.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -6715,23 +6715,33 @@
     }
 
     var nextMicroTask = Promise.resolve();
-    function defer(callback) {
+    function defer(callback, // arguments: the first caller of the window decides what the single run
+    // receives. Pass this to fold every later argument into the pending ones
+    // instead.
+    mergeArguments) {
         var progress = null;
         var cancelled = false;
+        var pendingArgs = null;
         var fn = function fn() {
             for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
                 args[_key] = arguments[_key];
             }
             if (progress !== null) {
+                if (mergeArguments && pendingArgs !== null) {
+                    pendingArgs = mergeArguments(pendingArgs, args);
+                }
                 return;
             }
+            pendingArgs = args;
             progress = nextMicroTask.then(function() {
                 progress = null;
+                var runArgs = pendingArgs;
+                pendingArgs = null;
                 if (cancelled) {
                     cancelled = false;
                     return;
                 }
-                callback.apply(void 0, _to_consumable_array(args));
+                callback.apply(void 0, _to_consumable_array(runArgs));
             });
         };
         fn.wait = function() {
@@ -7614,22 +7624,18 @@
                 clearTimeout(cleanupTimerRef.current);
                 // Warning: if an unstable function prop is provided, `dequal` is not able
                 // to keep its reference and therefore will consider that props did change.
-                // This could unsollicitely remove/add the widget, therefore forget its state,
-                // and could be a source of confusion.
+                // This unintentionally replaces the widget, which is wasteful (it causes
+                // a search), even though `updateWidget` below keeps its state.
                 // If users face this issue, we should advise them to provide stable function
                 // references.
                 var arePropsEqual = dequal(props, prevPropsRef.current);
-                // If props did change, then we execute the cleanup function instantly
-                // and then add the widget back. This lets us add the widget without
+                // If props did change, then we replace the widget instantly instead of
                 // waiting for the scheduled cleanup function to finish (that we canceled
-                // above).
+                // above). `updateWidget` hands the previous widget's `uiState` over to the
+                // new one, so that a parameter change doesn't reset the state the widget
+                // still owns — which would otherwise break routing.
                 if (!arePropsEqual) {
-                    parentIndex.removeWidgets([
-                        previousWidget
-                    ]);
-                    parentIndex.addWidgets([
-                        widget
-                    ]);
+                    parentIndex.updateWidget(previousWidget, widget);
                 }
             }
             return function() {
@@ -7988,6 +7994,11 @@
         return undefined;
     }
 
+    function reduceChildrenUiState(widgets, uiState, widgetUiStateOptions) {
+        return widgets.reduce(function(state, widget) {
+            return widget.getWidgetUiState ? widget.getWidgetUiState(state, widgetUiStateOptions) : state;
+        }, uiState);
+    }
     function createFeedContainer(feedID, parentIndex, instantSearchInstance) {
         var localWidgets = [];
         var initialized = false;
@@ -8189,13 +8200,10 @@
             },
             getWidgetUiState: function getWidgetUiState(uiState) {
                 var helper = parentIndex.getHelper();
-                var widgetUiStateOptions = {
+                return reduceChildrenUiState(localWidgets, uiState, {
                     searchParameters: helper.state,
                     helper: helper
-                };
-                return localWidgets.reduce(function(state, widget) {
-                    return widget.getWidgetUiState ? widget.getWidgetUiState(state, widgetUiStateOptions) : state;
-                }, uiState);
+                });
             },
             getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
                 var uiState = param.uiState;
@@ -8205,6 +8213,73 @@
                     }) : params;
                 }, searchParameters);
             },
+            updateWidget: function updateWidget(previousWidget, nextWidget) {
+                var helper = parentIndex.getHelper();
+                // The `uiState` the children own, read before the previous widget is
+                // detached, so that the state it owns can be handed over to the next one.
+                var previousUiState = helper ? reduceChildrenUiState(localWidgets, {}, {
+                    searchParameters: helper.state,
+                    helper: helper
+                }) : {};
+                previousWidget.parent = undefined;
+                nextWidget.parent = container;
+                // The next widget takes the place of the previous one, so that the order
+                // in which children contribute to the search parameters is unchanged.
+                var nextWidgets = localWidgets.slice();
+                var position = nextWidgets.indexOf(previousWidget);
+                if (position === -1) {
+                    nextWidgets.push(nextWidget);
+                } else {
+                    nextWidgets[position] = nextWidget;
+                }
+                localWidgets = nextWidgets;
+                if (!helper || !initialized) {
+                    return container;
+                }
+                // We still dispose the previous widget, for its side effects and so that
+                // it drops the search parameters it declared on the parent helper.
+                var cleanedState = helper.state;
+                if (previousWidget.dispose) {
+                    var next = previousWidget.dispose({
+                        helper: helper,
+                        state: cleanedState,
+                        recommendState: helper.recommendState,
+                        parent: container
+                    });
+                    if (next && !_instanceof(next, algoliasearchHelper.RecommendParameters)) {
+                        cleanedState = next;
+                    }
+                }
+                // We hand the previous `uiState` over to the children, then read the
+                // `uiState` back from them, so that state no mounted child claims anymore
+                // is dropped. This mirrors the index widget's `updateWidget`.
+                var narrowedUiState = reduceChildrenUiState(localWidgets, {}, {
+                    searchParameters: container.getWidgetSearchParameters(cleanedState, {
+                        uiState: previousUiState
+                    }),
+                    helper: helper
+                });
+                // The search parameters are then computed again from that narrowed
+                // `uiState`, so that they can't hold state the `uiState` doesn't describe.
+                var newState = container.getWidgetSearchParameters(cleanedState, {
+                    uiState: narrowedUiState
+                });
+                if (nextWidget.getRenderState) {
+                    var renderState = nextWidget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                    storeRenderState({
+                        renderState: renderState,
+                        instantSearchInstance: instantSearchInstance,
+                        parent: container
+                    });
+                }
+                if (nextWidget.init) {
+                    nextWidget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                }
+                if (newState !== helper.state) {
+                    helper.setState(newState);
+                }
+                return container;
+            },
             refreshUiState: function refreshUiState() {
             // no-op: FeedContainer doesn't own UI state
             },
@@ -8566,6 +8641,11 @@
         var helper = null;
         var derivedHelper = null;
         var lastValidSearchParameters = null;
+        // The error this index has already rolled back for. Renders also happen for
+        // reasons unrelated to a search (a chat panel opening, a recommend result,
+        // the stalled timer), and rolling back on every one of them would discard
+        // state written after the failed search.
+        var restoredForError;
         var recomputeLocalRequestDependencies = function recomputeLocalRequestDependencies() {
             if (localInstantSearchInstance) {
                 recomputeInstantSearchRequestDependencies(localInstantSearchInstance);
@@ -8705,6 +8785,92 @@
                 }
                 return this;
             },
+            updateWidget: function updateWidget(previousWidget, nextWidget) {
+                if (typeof previousWidget.dispose !== 'function') {
+                    throw new Error(withUsage$u('The widget definition expects a `dispose` method.'));
+                }
+                if (typeof nextWidget.init !== 'function' && typeof nextWidget.render !== 'function') {
+                    throw new Error(withUsage$u('The widget definition expects a `render` and/or an `init` method.'));
+                }
+                // The `uiState` as it is before the previous widget is detached, so that
+                // the state it owns can be handed over to the next widget.
+                var previousUiState = localUiState;
+                previousWidget.parent = undefined;
+                nextWidget.parent = this;
+                if (!isIndexWidget(nextWidget)) {
+                    addWidgetId(nextWidget);
+                }
+                // The next widget takes the place of the previous one, so that the order
+                // in which widgets contribute to the search parameters is unchanged.
+                var nextWidgets = localWidgets.slice();
+                var position = nextWidgets.indexOf(previousWidget);
+                if (position === -1) {
+                    nextWidgets.push(nextWidget);
+                } else {
+                    nextWidgets[position] = nextWidget;
+                }
+                localWidgets = nextWidgets;
+                recomputeLocalRequestDependencies();
+                if (!localInstantSearchInstance) {
+                    return this;
+                }
+                // We still dispose the previous widget, for its side effects. The search
+                // state it returns is only used as a base when shared state isn't preserved
+                // on unmount, like in `removeWidgets`.
+                var disposedState = previousWidget.dispose({
+                    helper: helper,
+                    state: helper.state,
+                    recommendState: helper.recommendState,
+                    parent: this
+                });
+                var cleanedRecommendState = _instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.recommendState;
+                var cleanedSearchState = disposedState && !_instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.state;
+                var initialSearchParameters = localInstantSearchInstance.future.preserveSharedStateOnUnmount ? new algoliasearchHelper.SearchParameters({
+                    index: this.getIndexName()
+                }) : cleanedSearchState;
+                // We hand the previous `uiState` over to the next widgets, then read the
+                // `uiState` back from them. Widgets only pick up the state they claim, so
+                // this drops state that no mounted widget owns anymore (an attribute that
+                // changed, for instance) instead of seeding it with `previousUiState`.
+                localUiState = getLocalWidgetsUiState(localWidgets, {
+                    searchParameters: getLocalWidgetsSearchParameters(localWidgets, {
+                        uiState: previousUiState,
+                        initialSearchParameters: initialSearchParameters
+                    }),
+                    helper: helper
+                });
+                // The search parameters are then computed again from that narrowed
+                // `uiState`, so that they can't hold state the `uiState` doesn't describe.
+                var newState = getLocalWidgetsSearchParameters(localWidgets, {
+                    uiState: localUiState,
+                    initialSearchParameters: initialSearchParameters
+                });
+                privateHelperSetState(helper, {
+                    state: newState,
+                    recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
+                        uiState: localUiState,
+                        initialRecommendParameters: cleanedRecommendState
+                    }),
+                    _uiState: localUiState
+                });
+                if (nextWidget.getRenderState) {
+                    var renderState = nextWidget.getRenderState(localInstantSearchInstance.renderState[this.getIndexId()] || {}, createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
+                    storeRenderState({
+                        renderState: renderState,
+                        instantSearchInstance: localInstantSearchInstance,
+                        parent: this
+                    });
+                }
+                if (nextWidget.init) {
+                    nextWidget.init(createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
+                }
+                if (isolated) {
+                    this.scheduleLocalSearch();
+                } else {
+                    localInstantSearchInstance.scheduleSearch();
+                }
+                return this;
+            },
             removeWidgets: function removeWidgets(widgets) {
                 var _this = this;
                 if (!Array.isArray(widgets)) {
@@ -8956,7 +9122,10 @@
                 var instantSearchInstance = param.instantSearchInstance;
                 // we can't attach a listener to the error event of search, as the error
                 // then would no longer be thrown for global handlers.
-                if (instantSearchInstance.status === 'error' && !instantSearchInstance.mainHelper.hasPendingRequests() && lastValidSearchParameters) {
+                if (instantSearchInstance.status !== 'error') {
+                    restoredForError = undefined;
+                } else if (instantSearchInstance.error !== restoredForError && !instantSearchInstance.mainHelper.hasPendingRequests() && lastValidSearchParameters) {
+                    restoredForError = instantSearchInstance.error;
                     helper.setState(lastValidSearchParameters);
                 }
                 // We only render index widgets if there are no results.
@@ -9223,7 +9392,7 @@
         });
     }
 
-    var version = '4.112.0';
+    var version = '4.114.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -11135,6 +11304,14 @@
                     instantSearchInstance: _this
                 });
                 _this.emit('render');
+            }, // status reset accumulates instead of letting the first caller decide: a
+            // render scheduled for a reason unrelated to the search must not cancel the
+            // one a search result asks for, or it would strand the status on `loading`.
+            function(param, param1) {
+                var _param = _sliced_to_array(param, 1), tmp = _param[0], shouldResetStatus = tmp === void 0 ? true : tmp, _param1 = _sliced_to_array(param1, 1), tmp1 = _param1[0], nextShouldResetStatus = tmp1 === void 0 ? true : tmp1;
+                return [
+                    shouldResetStatus || nextShouldResetStatus
+                ];
             })), _define_property(_this, "onInternalStateChange", defer(function() {
                 var nextUiState = _this.mainIndex.getWidgetUiState({});
                 _this.middleware.forEach(function(param) {
@@ -13953,19 +14130,168 @@
             return laterPart.type !== 'reasoning' || laterPart.state === 'streaming';
         });
     }
-    var findTool = function findTool(partType, tools) {
-        var toolName = partType.replace('tool-', '');
-        var tool = tools[toolName];
-        if (!tool) {
-            var _Object_entries_find;
-            tool = (_Object_entries_find = Object.entries(tools).find(function(param) {
-                var _param = _sliced_to_array(param, 1), key = _param[0];
-                return startsWith(toolName, "".concat(key, "_"));
-            })) === null || _Object_entries_find === void 0 ? void 0 : _Object_entries_find[1];
-        }
-        return tool;
+    /**
+     * Whether a text part renders nothing. `text-start` creates the part before its
+     * first delta, and `<context>` wrappers are a shim `ChatMessage` also drops.
+     */ var isPartTextEmpty = function isPartTextEmpty(part) {
+        return part.text.trim().length === 0 || part.text.startsWith('<context>') && part.text.endsWith('</context>');
+    };
+    /**
+     * Whether a part says something about the turn's progress. Data parts and
+     * unwritten text parts render nothing, so reading them would answer "what is
+     * this turn doing" with a part that changed nothing on screen.
+     */ var isPartProgressSignal = function isPartProgressSignal(part) {
+        if (startsWith(part.type, 'data-')) {
+            return false;
+        }
+        if (isPartText(part)) {
+            return !isPartTextEmpty(part);
+        }
+        return true;
+    };
+    var findLastProgressPart = function findLastProgressPart(parts) {
+        if (!parts) {
+            return undefined;
+        }
+        for(var index = parts.length - 1; index >= 0; index--){
+            var part = parts[index];
+            if (isPartProgressSignal(part)) {
+                return part;
+            }
+        }
+        return undefined;
+    };
+    var TOOL_PART_PREFIX = 'tool-';
+    /**
+     * Resolves the tool a message part belongs to, from either a part type
+     * (`tool-algolia_search_index`) or a bare tool name.
+     *
+     * An exact registration wins. Otherwise only tools whose `matchesToolName`
+     * claims the name are considered, most specific first, for servers that name a
+     * call after the registered tool: the Algolia MCP Server appends the index name
+     * (`algolia_search_index_products`).
+     *
+     * Generic over the tool shape: the renderer, the loader, the widget and the
+     * connector hold different subsets of the tool contract.
+     */ var findTool = function findTool(partType, tools) {
+        var toolName = startsWith(partType, TOOL_PART_PREFIX) ? partType.slice(TOOL_PART_PREFIX.length) : partType;
+        if (tools[toolName]) {
+            return tools[toolName];
+        }
+        var claimants = Object.keys(tools).filter(function(key) {
+            var _tools_key_matchesToolName, _tools_key;
+            return Boolean((_tools_key = tools[key]) === null || _tools_key === void 0 ? void 0 : (_tools_key_matchesToolName = _tools_key.matchesToolName) === null || _tools_key_matchesToolName === void 0 ? void 0 : _tools_key_matchesToolName.call(_tools_key, toolName));
+        });
+        if (claimants.length === 0) {
+            return undefined;
+        }
+        // Most specific claim wins, ties by name, so the winner doesn't depend on
+        // registration order.
+        claimants.sort(function(a, b) {
+            return b.length - a.length || (a < b ? -1 : 1);
+        });
+        return tools[claimants[0]];
     };
     var FACET_KEY_PREFIX = 'facet_';
+    /**
+     * A numeric facet value as the Algolia MCP Server emits it: an operator
+     * followed by a number (`'<=1500'`). Mirrors that server's own
+     * `NUMERIC_FILTER_REGEX` so the two sides cannot drift.
+     */ var NUMERIC_FACET_VALUE = /^(<=|>=|=|!=|<|>)\s*(-?\d+(\.\d+)?)$/;
+    var isNumericFacetValues = function isNumericFacetValues(values) {
+        return values.length > 0 && values.every(function(value) {
+            return NUMERIC_FACET_VALUE.test(value);
+        });
+    };
+    /**
+     * The key the Algolia MCP Server attaches its resolved search parameters under,
+     * on the tool result's `_meta`. Agent Studio forwards this one key to the
+     * browser by allowlist, as a `data-tool-output-metadata` part correlated by
+     * `toolCallId`.
+     *
+     * These params are the filters the server actually searched with, after
+     * defaults, clamping and the allow-list — including ones the model never saw.
+     * That makes them exact where the raw `facet_` keys are ambiguous.
+     */ var RESOLVED_SEARCH_PARAMS_META_KEY = 'com.algolia/resolved-search-params';
+    var TOOL_OUTPUT_METADATA_PART_TYPE = 'data-tool-output-metadata';
+    var isStringArray = function isStringArray(value) {
+        return Array.isArray(value) && value.every(function(item) {
+            return typeof item === 'string';
+        });
+    };
+    var RESOLVED_SEARCH_PARAMS_KEYS = [
+        'query',
+        'facetFilters',
+        'numericFilters'
+    ];
+    /**
+     * Recognizes a single resolved-params bag by shape.
+     *
+     * The server attaches the same `_meta` key in three shapes: one bag for a
+     * single-index search, one bag per variation (an array) for a bulk search, and
+     * a per-index map for a multi-index search. Only the single bag can be read
+     * here. An array or a map parses to nothing, and an empty bag would still beat
+     * the raw `facet_` keys and search with the query alone — so the other two
+     * shapes are left to the fallback path instead.
+     */ var isResolvedSearchParamsBag = function isResolvedSearchParamsBag(value) {
+        return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && !Array.isArray(value) && RESOLVED_SEARCH_PARAMS_KEYS.some(function(key) {
+            return key in value;
+        });
+    };
+    /**
+     * Reads the resolved search params a search tool call was answered with.
+     *
+     * The metadata arrives as a transient data part next to the tool call. It is
+     * read from `messages` rather than through `onData` because the chat retains
+     * every `data-*` part on the message, which covers the live and the replayed
+     * conversation with one path. Returns `undefined` when the part is absent —
+     * the case whenever the server does not emit `_meta` — or when its value is
+     * not a single params bag, so that the caller falls back to the raw
+     * `facet_` keys instead of searching with no filters at all.
+     */ var getResolvedSearchParams = function getResolvedSearchParams(messages, toolCallId) {
+        if (!messages || !toolCallId) {
+            return undefined;
+        }
+        // Newest first: a re-answered tool call should win over its earlier result.
+        for(var i = messages.length - 1; i >= 0; i--){
+            var _messages_i;
+            var parts = (_messages_i = messages[i]) === null || _messages_i === void 0 ? void 0 : _messages_i.parts;
+            if (!Array.isArray(parts)) {
+                continue;
+            }
+            for(var j = parts.length - 1; j >= 0; j--){
+                var _data_metadata;
+                var part = parts[j];
+                if (!part || part.type !== TOOL_OUTPUT_METADATA_PART_TYPE) {
+                    continue;
+                }
+                var data = part.data;
+                if ((data === null || data === void 0 ? void 0 : data.toolCallId) !== toolCallId) {
+                    continue;
+                }
+                var resolved = (_data_metadata = data.metadata) === null || _data_metadata === void 0 ? void 0 : _data_metadata[RESOLVED_SEARCH_PARAMS_META_KEY];
+                if (!isResolvedSearchParamsBag(resolved)) {
+                    continue;
+                }
+                // Algolia reads a plain string entry as its own group, and the search
+                // tool's schema accepts that mixed form
+                // (`['category:Books', ['author:Alice', 'author:Bob']]`), so a flat
+                // entry is a normal producer output.
+                var facetFilters = Array.isArray(resolved.facetFilters) ? resolved.facetFilters.map(function(entry) {
+                    return typeof entry === 'string' ? [
+                        entry
+                    ] : entry;
+                }).filter(isStringArray) : undefined;
+                var numericFilters = isStringArray(resolved.numericFilters) ? resolved.numericFilters : undefined;
+                return {
+                    query: typeof resolved.query === 'string' ? resolved.query : undefined,
+                    facetFilters: facetFilters && facetFilters.length > 0 ? facetFilters : undefined,
+                    numericFilters: numericFilters && numericFilters.length > 0 ? numericFilters : undefined
+                };
+            }
+        }
+        return undefined;
+    };
     var hasQueries = function hasQueries(input) {
         return Array.isArray(input.queries);
     };
@@ -13984,18 +14310,41 @@
         }
         var facetFilters = Object.entries(query).reduce(function(acc, param) {
             var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-            if (!startsWith(key, FACET_KEY_PREFIX) || !Array.isArray(value)) {
+            if (!startsWith(key, FACET_KEY_PREFIX)) {
                 return acc;
             }
             var attribute = key.slice(FACET_KEY_PREFIX.length);
+            if (!attribute) {
+                return acc;
+            }
+            // A boolean facet arrives as a primitive, not an array.
+            if (typeof value === 'boolean') {
+                acc.push([
+                    "".concat(attribute, ":").concat(value)
+                ]);
+                return acc;
+            }
+            if (!Array.isArray(value)) {
+                return acc;
+            }
             var values = value.filter(function(item) {
                 return typeof item === 'string';
             });
-            if (attribute && values.length > 0) {
-                acc.push(values.map(function(item) {
-                    return "".concat(attribute, ":").concat(item);
-                }));
+            if (values.length === 0) {
+                return acc;
             }
+            // A numeric facet needs a numeric refinement, which this shape cannot
+            // express. `price:<=1500` would refine on a value no record holds, so the
+            // search would quietly return the wrong results. Dropping it loses the
+            // filter instead, which the user can see. Where the tool's resolved
+            // search params are available, `getResolvedSearchParams` applies the
+            // numeric refinement properly and this path is not reached.
+            if (isNumericFacetValues(values)) {
+                return acc;
+            }
+            acc.push(values.map(function(item) {
+                return "".concat(attribute, ":").concat(item);
+            }));
             return acc;
         }, []);
         return facetFilters.length > 0 ? facetFilters : undefined;
@@ -14008,8 +14357,24 @@
      * Algolia MCP Server search tool instead expresses refinements as individual
      * `facet_<attribute>` keys (e.g. `facet_categories: ['Books', 'Toys']`), which
      * are converted here into `[['attribute:value']]`.
-     */ var getApplyFiltersParamsFromToolInput = function getApplyFiltersParamsFromToolInput(input) {
+     *
+     * Pass `resolved` (from `getResolvedSearchParams`) to use the filters the
+     * server actually searched with instead of re-deriving them from the raw keys.
+     * That is the only way to apply a numeric refinement.
+     */ var getApplyFiltersParamsFromToolInput = function getApplyFiltersParamsFromToolInput(input, resolved) {
         var query = getSearchToolQuery(input);
+        // The resolved params are what the server actually searched with, so they win
+        // wherever they exist. Only they can express a numeric refinement: a numeric
+        // facet and a string facet whose value is literally `'<=1500'` are identical
+        // in the raw `facet_` keys.
+        if (resolved) {
+            var _resolved_query;
+            return {
+                query: (_resolved_query = resolved.query) !== null && _resolved_query !== void 0 ? _resolved_query : query === null || query === void 0 ? void 0 : query.query,
+                facetFilters: resolved.facetFilters,
+                numericFilters: resolved.numericFilters
+            };
+        }
         return {
             query: query === null || query === void 0 ? void 0 : query.query,
             facetFilters: getFacetFilters(query)
@@ -14130,8 +14495,6 @@
             sendEvent: context.sendEvent
         };
     }
-    // Keep in sync with packages/instantsearch.js/src/lib/chat/index.ts
-    var SearchIndexToolType$1 = 'algolia_search_index';
     function createChatMessageComponent(param) {
         var createElement = param.createElement, Fragment = param.Fragment;
         var Button = createButtonComponent({
@@ -14142,7 +14505,7 @@
         });
         return function ChatMessage(userProps) {
             var _messages_;
-            var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, message = userProps.message, _userProps_side = userProps.side, side = _userProps_side === void 0 ? 'left' : _userProps_side, _userProps_variant = userProps.variant, variant = _userProps_variant === void 0 ? 'subtle' : _userProps_variant, _userProps_actions = userProps.actions, actions = _userProps_actions === void 0 ? [] : _userProps_actions, _userProps_autoHideActions = userProps.autoHideActions, autoHideActions = _userProps_autoHideActions === void 0 ? false : _userProps_autoHideActions, LeadingComponent = userProps.leadingComponent, ActionsComponent = userProps.actionsComponent, FooterComponent = userProps.footerComponent, TextComponent = userProps.textComponent, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, userTranslations = userProps.translations, suggestionsElement = userProps.suggestionsElement, _userProps_showReasoning = userProps.showReasoning, showReasoning = _userProps_showReasoning === void 0 ? false : _userProps_showReasoning, _userProps_parseMarkdown = userProps.parseMarkdown, parseMarkdown = _userProps_parseMarkdown === void 0 ? true : _userProps_parseMarkdown, ownMessages = userProps.messages, /* eslint-disable typescript/no-deprecated -- reading the
+            var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, message = userProps.message, _userProps_side = userProps.side, side = _userProps_side === void 0 ? 'left' : _userProps_side, _userProps_variant = userProps.variant, variant = _userProps_variant === void 0 ? 'subtle' : _userProps_variant, _userProps_actions = userProps.actions, actions = _userProps_actions === void 0 ? [] : _userProps_actions, _userProps_autoHideActions = userProps.autoHideActions, autoHideActions = _userProps_autoHideActions === void 0 ? false : _userProps_autoHideActions, LeadingComponent = userProps.leadingComponent, ActionsComponent = userProps.actionsComponent, FooterComponent = userProps.footerComponent, TextComponent = userProps.textComponent, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, userTranslations = userProps.translations, suggestionsElement = userProps.suggestionsElement, loaderElement = userProps.loaderElement, _userProps_showReasoning = userProps.showReasoning, showReasoning = _userProps_showReasoning === void 0 ? false : _userProps_showReasoning, _userProps_parseMarkdown = userProps.parseMarkdown, parseMarkdown = _userProps_parseMarkdown === void 0 ? true : _userProps_parseMarkdown, ownMessages = userProps.messages, /* eslint-disable typescript/no-deprecated -- reading the
              deprecated aliases is the point: they are resolved into `context`
              below so callers on the previous API keep working. */ ownStatus = userProps.status, ownTools = userProps.tools, ownOnClose = userProps.onClose, /* eslint-enable typescript/no-deprecated */ sharedContext = userProps.context, props = _object_without_properties(userProps, [
                 "classNames",
@@ -14159,6 +14522,7 @@
                 "setIndexUiState",
                 "translations",
                 "suggestionsElement",
+                "loaderElement",
                 "showReasoning",
                 "parseMarkdown",
                 "messages",
@@ -14273,15 +14637,12 @@
                     }, markdown);
                 }
                 if (startsWith(part.type, 'tool-')) {
-                    var _message_metadata;
-                    var toolName = part.type.replace('tool-', '');
-                    var tool = tools[toolName];
-                    // Compatibility shim with Algolia MCP Server search tool
-                    if (!tool && startsWith(toolName, "".concat(SearchIndexToolType$1, "_"))) {
-                        tool = tools[SearchIndexToolType$1];
-                    }
-                    var displayResultsEnabled = ((_message_metadata = message.metadata) === null || _message_metadata === void 0 ? void 0 : _message_metadata.displayResultsEnabled) === true;
-                    if (displayResultsEnabled && tool && tool === tools[SearchIndexToolType$1]) {
+                    var _tool_shouldRender;
+                    var tool = findTool(part.type, tools);
+                    if ((tool === null || tool === void 0 ? void 0 : (_tool_shouldRender = tool.shouldRender) === null || _tool_shouldRender === void 0 ? void 0 : _tool_shouldRender.call(tool, _object_spread_props(_object_spread({}, context), {
+                        message: part,
+                        parentMessage: message
+                    }))) === false) {
                         return null;
                     }
                     if (tool) {
@@ -14350,7 +14711,7 @@
                 className: cx(cssClasses.content)
             }, /*#__PURE__*/ createElement("div", {
                 className: cx(cssClasses.message)
-            }, message.parts.map(renderMessagePart)), suggestionsElement, showActions && /*#__PURE__*/ createElement("div", {
+            }, message.parts.map(renderMessagePart), loaderElement), suggestionsElement, showActions && /*#__PURE__*/ createElement("div", {
                 className: cx(cssClasses.actions),
                 "aria-label": translations.actionsLabel
             }, ActionsComponent ? /*#__PURE__*/ createElement(ActionsComponent, {
@@ -14453,28 +14814,23 @@
     function createChatMessageLoaderComponent(param) {
         var createElement = param.createElement;
         return function ChatMessageLoader(userProps) {
-            var userTranslations = userProps.translations;
+            var userTranslations = userProps.translations, _userProps_inline = userProps.inline, inline = _userProps_inline === void 0 ? false : _userProps_inline, className = userProps.className; // The turn context is for custom loaders, not for the DOM.
             userProps.context;
             var props = _object_without_properties(userProps, [
                 "translations",
+                "inline",
+                "className",
                 "context"
             ]);
             var translations = _object_spread({
                 loaderText: ''
             }, userTranslations);
-            return /*#__PURE__*/ createElement("article", _object_spread({
-                className: "ais-ChatMessageLoader ais-ChatMessage ais-ChatMessage--left ais-ChatMessage--subtle"
-            }, props), /*#__PURE__*/ createElement("div", {
-                className: "ais-ChatMessage-container"
-            }, /*#__PURE__*/ createElement("div", {
-                className: "ais-ChatMessage-leading"
-            }, /*#__PURE__*/ createElement("div", {
+            var spinner = /*#__PURE__*/ createElement("div", {
                 className: "ais-ChatMessageLoader-spinner"
             }, /*#__PURE__*/ createElement(LoadingSpinnerIcon, {
                 createElement: createElement
-            }))), /*#__PURE__*/ createElement("div", {
-                className: "ais-ChatMessage-content"
-            }, /*#__PURE__*/ createElement("div", {
+            }));
+            var body = /*#__PURE__*/ createElement("div", {
                 className: "ais-ChatMessage-message"
             }, translations.loaderText && /*#__PURE__*/ createElement("div", {
                 className: "ais-ChatMessageLoader-text"
@@ -14484,13 +14840,30 @@
                 className: "ais-ChatMessageLoader-skeletonItem"
             }), /*#__PURE__*/ createElement("div", {
                 className: "ais-ChatMessageLoader-skeletonItem"
-            }))))));
+            })));
+            if (inline) {
+                return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
+                    className: cx('ais-ChatMessageLoader', 'ais-ChatMessageLoader--inline', className)
+                }), spinner, body);
+            }
+            return /*#__PURE__*/ createElement("article", _object_spread_props(_object_spread({}, props), {
+                className: cx('ais-ChatMessageLoader ais-ChatMessage ais-ChatMessage--left ais-ChatMessage--subtle', className)
+            }), /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatMessage-container"
+            }, /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatMessage-leading"
+            }, spinner), /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatMessage-content"
+            }, body)));
         };
     }
 
     var copyToClipboard = function copyToClipboard(message) {
         navigator.clipboard.writeText(getTextContent(message));
     };
+    var DEFAULT_LOADER_SHOW_DELAY = 250;
+    // Short enough that it never lingers over the content that replaced it.
+    var DEFAULT_LOADER_MIN_DURATION = 200;
     function getInstantSearchStatus(tools) {
         var _Object_values_find_insightsEventContext, _Object_values_find;
         return (_Object_values_find = Object.values(tools).find(function(tool) {
@@ -14509,7 +14882,7 @@
             Fragment: Fragment
         });
         return function DefaultMessage(param) {
-            var message = param.message, userMessageProps = param.userMessageProps, assistantMessageProps = param.assistantMessageProps, indexUiState = param.indexUiState, setIndexUiState = param.setIndexUiState, onReload = param.onReload, onFeedback = param.onFeedback, feedbackState = param.feedbackState, actionsComponent = param.actionsComponent, classNames = param.classNames, messageTranslations = param.messageTranslations, translations = param.translations, suggestionsElement = param.suggestionsElement, context = param.context;
+            var message = param.message, userMessageProps = param.userMessageProps, assistantMessageProps = param.assistantMessageProps, indexUiState = param.indexUiState, setIndexUiState = param.setIndexUiState, onReload = param.onReload, onFeedback = param.onFeedback, feedbackState = param.feedbackState, actionsComponent = param.actionsComponent, classNames = param.classNames, messageTranslations = param.messageTranslations, translations = param.translations, suggestionsElement = param.suggestionsElement, loaderElement = param.loaderElement, context = param.context;
             var defaultAssistantActions = _to_consumable_array(hasTextContent(message) ? [
                 {
                     title: translations.copyToClipboardLabel,
@@ -14600,6 +14973,7 @@
                 classNames: classNames,
                 translations: messageTranslations,
                 suggestionsElement: suggestionsElement,
+                loaderElement: loaderElement,
                 context: context
             }, messageProps), {
                 message: message,
@@ -14608,10 +14982,128 @@
         };
     }
     function createChatMessagesComponent(param) {
-        var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo;
+        var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo, useState = param.useState, useEffect = param.useEffect;
         var Button = createButtonComponent({
             createElement: createElement
         });
+        /**
+       * Smooths the loading state into a visibility. Several transitions in a turn
+       * flip it twice within a few frames, which reads as the loader popping in and
+       * out, so a loader coming back mid-turn waits out `showDelay` and a visible
+       * one holds for `minDuration`.
+       */ function useLoaderVisibility(param) {
+            var isLoading = param.isLoading, isTurnActive = param.isTurnActive, showDelay = param.showDelay, minDuration = param.minDuration;
+            var _useState = _sliced_to_array(useState({
+                phase: 'idle'
+            }), 2), loaderState = _useState[0], setLoaderState = _useState[1];
+            var isVisible = isTurnActive && (isLoading && (loaderState.phase === 'idle' || loaderState.phase === 'ready' || loaderState.phase === 'hidden' && showDelay <= 0) || loaderState.phase === 'visible' && (isLoading || minDuration > loaderState.elapsedDuration));
+            useEffect(function() {
+                if (!isTurnActive) {
+                    if (loaderState.phase !== 'idle') {
+                        setLoaderState({
+                            phase: 'idle'
+                        });
+                    }
+                    return undefined;
+                }
+                if (loaderState.phase === 'idle') {
+                    if (isLoading) {
+                        setLoaderState({
+                            phase: 'visible',
+                            shownAt: Date.now(),
+                            elapsedDuration: 0
+                        });
+                    }
+                    return undefined;
+                }
+                if (loaderState.phase === 'visible') {
+                    if (!isLoading && minDuration <= loaderState.elapsedDuration) {
+                        setLoaderState({
+                            phase: 'hidden'
+                        });
+                        return undefined;
+                    }
+                    if (minDuration <= loaderState.elapsedDuration) {
+                        return undefined;
+                    }
+                    var remaining = Math.max(0, loaderState.shownAt + minDuration - Date.now());
+                    if (remaining === 0) {
+                        setLoaderState(_object_spread_props(_object_spread({}, loaderState), {
+                            elapsedDuration: minDuration
+                        }));
+                        return undefined;
+                    }
+                    var timer = setTimeout(function() {
+                        setLoaderState(function(current) {
+                            return current.phase === 'visible' && current.shownAt === loaderState.shownAt ? _object_spread_props(_object_spread({}, current), {
+                                elapsedDuration: Math.max(current.elapsedDuration, minDuration)
+                            }) : current;
+                        });
+                    }, remaining);
+                    return function() {
+                        return clearTimeout(timer);
+                    };
+                }
+                if (loaderState.phase === 'hidden') {
+                    if (isLoading) {
+                        var now = Date.now();
+                        setLoaderState(showDelay <= 0 ? {
+                            phase: 'visible',
+                            shownAt: now,
+                            elapsedDuration: 0
+                        } : {
+                            phase: 'waiting',
+                            pendingSince: now
+                        });
+                    }
+                    return undefined;
+                }
+                if (loaderState.phase === 'ready') {
+                    setLoaderState(isLoading ? {
+                        phase: 'visible',
+                        shownAt: loaderState.shownAt,
+                        elapsedDuration: loaderState.elapsedDuration
+                    } : {
+                        phase: 'hidden'
+                    });
+                    return undefined;
+                }
+                if (!isLoading) {
+                    setLoaderState({
+                        phase: 'hidden'
+                    });
+                    return undefined;
+                }
+                var remaining1 = Math.max(0, loaderState.pendingSince + showDelay - Date.now());
+                if (remaining1 === 0) {
+                    setLoaderState({
+                        phase: 'visible',
+                        shownAt: Date.now(),
+                        elapsedDuration: 0
+                    });
+                    return undefined;
+                }
+                var timer1 = setTimeout(function() {
+                    setLoaderState(function(current) {
+                        return current.phase === 'waiting' && current.pendingSince === loaderState.pendingSince ? {
+                            phase: 'ready',
+                            shownAt: Date.now(),
+                            elapsedDuration: 0
+                        } : current;
+                    });
+                }, remaining1);
+                return function() {
+                    return clearTimeout(timer1);
+                };
+            }, [
+                isLoading,
+                isTurnActive,
+                loaderState,
+                minDuration,
+                showDelay
+            ]);
+            return isVisible;
+        }
         var DefaultMessageComponent = createDefaultMessageComponent({
             createElement: createElement,
             Fragment: Fragment
@@ -14632,6 +15124,12 @@
             var showReasoning = messageProps === null || messageProps === void 0 ? void 0 : messageProps.showReasoning;
             var parseMarkdown = messageProps === null || messageProps === void 0 ? void 0 : messageProps.parseMarkdown;
             var textComponent = messageProps === null || messageProps === void 0 ? void 0 : messageProps.textComponent;
+            // A completed row is memoized against its own message, but `shouldRender`
+            // reads the whole `context`: a predicate can hide an older tool result once a
+            // newer message arrives. Track the verdicts themselves rather than
+            // `context.messages`, so the row re-renders exactly when one flips instead of
+            // on every streaming delta.
+            var shouldRenderVerdicts = getShouldRenderVerdicts(props.context, props.message);
             // Custom text components receive the conversation, so their completed rows
             // must update with it. Keep the default renderer's streaming optimization.
             var textComponentMessages = textComponent ? props.context.messages : undefined;
@@ -14659,10 +15157,12 @@
                 props.message,
                 props.isCurrentMessage,
                 props.status,
+                shouldRenderVerdicts,
                 props.context.maximized,
                 props.context.open,
                 instantSearchStatus,
                 props.suggestionsElement,
+                props.loaderElement,
                 messageFeedback,
                 showReasoning,
                 parseMarkdown,
@@ -14687,17 +15187,21 @@
         return function ChatMessages(userProps) {
             var _ref;
             var _lastMessage_parts, _lastMessage_parts1;
-            var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, _userProps_messageClassNames = userProps.messageClassNames, messageClassNames = _userProps_messageClassNames === void 0 ? {} : _userProps_messageClassNames, messageTranslations = userProps.messageTranslations, _userProps_messages = userProps.messages, messages = _userProps_messages === void 0 ? [] : _userProps_messages, MessageComponent = userProps.messageComponent, LoaderComponent = userProps.loaderComponent, ErrorComponent = userProps.errorComponent, EmptyComponent = userProps.emptyComponent, ActionsComponent = userProps.actionsComponent, tools = userProps.tools, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, _userProps_status = userProps.status, status = _userProps_status === void 0 ? 'ready' : _userProps_status, error = userProps.error, _userProps_hideScrollToBottom = userProps.hideScrollToBottom, hideScrollToBottom = _userProps_hideScrollToBottom === void 0 ? false : _userProps_hideScrollToBottom, onReload = userProps.onReload, onNewConversation = userProps.onNewConversation, onClose = userProps.onClose, sendMessage = userProps.sendMessage, _userProps_regenerate = userProps.regenerate, regenerate = _userProps_regenerate === void 0 ? function() {
+            var _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames, _userProps_messageClassNames = userProps.messageClassNames, messageClassNames = _userProps_messageClassNames === void 0 ? {} : _userProps_messageClassNames, messageTranslations = userProps.messageTranslations, _userProps_messages = userProps.messages, messages = _userProps_messages === void 0 ? [] : _userProps_messages, MessageComponent = userProps.messageComponent, LoaderComponent = userProps.loaderComponent, _userProps_loaderPosition = userProps.loaderPosition, loaderPosition = _userProps_loaderPosition === void 0 ? 'messages-end' : _userProps_loaderPosition, shouldShowLoader = userProps.shouldShowLoader, _userProps_loaderShowDelay = userProps.loaderShowDelay, loaderShowDelay = _userProps_loaderShowDelay === void 0 ? DEFAULT_LOADER_SHOW_DELAY : _userProps_loaderShowDelay, _userProps_loaderMinDuration = userProps.loaderMinDuration, loaderMinDuration = _userProps_loaderMinDuration === void 0 ? DEFAULT_LOADER_MIN_DURATION : _userProps_loaderMinDuration, ErrorComponent = userProps.errorComponent, EmptyComponent = userProps.emptyComponent, ActionsComponent = userProps.actionsComponent, tools = userProps.tools, indexUiState = userProps.indexUiState, setIndexUiState = userProps.setIndexUiState, _userProps_status = userProps.status, status = _userProps_status === void 0 ? 'ready' : _userProps_status, error = userProps.error, _userProps_hideScrollToBottom = userProps.hideScrollToBottom, hideScrollToBottom = _userProps_hideScrollToBottom === void 0 ? false : _userProps_hideScrollToBottom, onReload = userProps.onReload, onNewConversation = userProps.onNewConversation, onClose = userProps.onClose, sendMessage = userProps.sendMessage, _userProps_regenerate = userProps.regenerate, regenerate = _userProps_regenerate === void 0 ? function() {
                 return Promise.resolve();
             } : _userProps_regenerate, _userProps_stop = userProps.stop, stop = _userProps_stop === void 0 ? function() {
                 return Promise.resolve();
-            } : _userProps_stop, _userProps_open = userProps.open, open = _userProps_open === void 0 ? false : _userProps_open, _userProps_maximized = userProps.maximized, maximized = _userProps_maximized === void 0 ? false : _userProps_maximized, setInput = userProps.setInput, userTranslations = userProps.translations, userMessageProps = userProps.userMessageProps, assistantMessageProps = userProps.assistantMessageProps, _userProps_isClearing = userProps.isClearing, isClearing = _userProps_isClearing === void 0 ? false : _userProps_isClearing, onClearTransitionEnd = userProps.onClearTransitionEnd, isScrollAtBottom = userProps.isScrollAtBottom, scrollRef = userProps.scrollRef, contentRef = userProps.contentRef, onScrollToBottom = userProps.onScrollToBottom, suggestionsElement = userProps.suggestionsElement, onFeedback = userProps.onFeedback, feedbackState = userProps.feedbackState, props = _object_without_properties(userProps, [
+            } : _userProps_stop, _userProps_open = userProps.open, open = _userProps_open === void 0 ? false : _userProps_open, _userProps_maximized = userProps.maximized, maximized = _userProps_maximized === void 0 ? false : _userProps_maximized, setInput = userProps.setInput, userTranslations = userProps.translations, userMessageProps = userProps.userMessageProps, assistantMessageProps = userProps.assistantMessageProps, _userProps_isClearing = userProps.isClearing, isClearing = _userProps_isClearing === void 0 ? false : _userProps_isClearing, onClearTransitionEnd = userProps.onClearTransitionEnd, isScrollAtBottom = userProps.isScrollAtBottom, scrollRef = userProps.scrollRef, contentRef = userProps.contentRef, onScrollToBottom = userProps.onScrollToBottom, suggestionsElement = userProps.suggestionsElement, _userProps_suggestionsLoading = userProps.suggestionsLoading, suggestionsLoading = _userProps_suggestionsLoading === void 0 ? false : _userProps_suggestionsLoading, onFeedback = userProps.onFeedback, feedbackState = userProps.feedbackState, props = _object_without_properties(userProps, [
                 "classNames",
                 "messageClassNames",
                 "messageTranslations",
                 "messages",
                 "messageComponent",
                 "loaderComponent",
+                "loaderPosition",
+                "shouldShowLoader",
+                "loaderShowDelay",
+                "loaderMinDuration",
                 "errorComponent",
                 "emptyComponent",
                 "actionsComponent",
@@ -14726,6 +15230,7 @@
                 "contentRef",
                 "onScrollToBottom",
                 "suggestionsElement",
+                "suggestionsLoading",
                 "onFeedback",
                 "feedbackState"
             ]);
@@ -14746,6 +15251,7 @@
                 scrollToBottomHidden: cx('ais-ChatMessages-scrollToBottom--hidden', classNames.scrollToBottomHidden)
             };
             var lastMessage = messages[messages.length - 1];
+            var showReasoning = assistantMessageProps === null || assistantMessageProps === void 0 ? void 0 : assistantMessageProps.showReasoning;
             var lastPart = lastMessage === null || lastMessage === void 0 ? void 0 : (_lastMessage_parts = lastMessage.parts) === null || _lastMessage_parts === void 0 ? void 0 : _lastMessage_parts[lastMessage.parts.length - 1];
             // `activePart` means "the part currently being processed". It must clear
             // when nothing is in progress: once the response settles (`ready`/`error`),
@@ -14756,10 +15262,13 @@
             var activePart = isProcessing && (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant' ? lastPart : undefined;
             // The scan slices the remaining parts per candidate, and only the loader reads
             // it, so skip it entirely while the opt-in is off.
-            var hasActiveReasoning = (assistantMessageProps === null || assistantMessageProps === void 0 ? void 0 : assistantMessageProps.showReasoning) ? (_ref = lastMessage === null || lastMessage === void 0 ? void 0 : (_lastMessage_parts1 = lastMessage.parts) === null || _lastMessage_parts1 === void 0 ? void 0 : _lastMessage_parts1.some(function(_, index, parts) {
+            // The loader reports on the assistant's turn, so it only ever belongs to an
+            // assistant message. While `submitted` the last message is still the user's
+            // own, and the loader belongs to no message at all.
+            var loaderMessage = (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant' ? lastMessage : undefined;
+            var hasActiveReasoning = showReasoning ? (_ref = lastMessage === null || lastMessage === void 0 ? void 0 : (_lastMessage_parts1 = lastMessage.parts) === null || _lastMessage_parts1 === void 0 ? void 0 : _lastMessage_parts1.some(function(_, index, parts) {
                 return isReasoningPartActive(parts, index);
             })) !== null && _ref !== void 0 ? _ref : false : false;
-            var showLoader = getShowLoader(status, lastPart, tools, assistantMessageProps === null || assistantMessageProps === void 0 ? void 0 : assistantMessageProps.showReasoning, hasActiveReasoning);
             // The shared context handed to every overridable chat component, so custom
             // components can read the current chat state and common callbacks from a
             // single, consistent place.
@@ -14780,14 +15289,45 @@
                 onNewConversation: onNewConversation,
                 onClose: onClose
             };
+            // The loader also reads what the turn is doing, which no other component
+            // needs, so its context extends the shared one.
+            var loaderContext = _object_spread_props(_object_spread({}, context), {
+                phase: getLoaderPhase(status, loaderMessage, showReasoning),
+                message: loaderMessage
+            });
+            var defaultShowLoader = getShowLoader(context, showReasoning, hasActiveReasoning);
+            var isLoading = shouldShowLoader ? shouldShowLoader(_object_spread_props(_object_spread({}, loaderContext), {
+                defaultValue: defaultShowLoader
+            })) : defaultShowLoader;
+            var showLoader = useLoaderVisibility({
+                isLoading: isLoading,
+                isTurnActive: isProcessing,
+                showDelay: loaderShowDelay,
+                minDuration: loaderMinDuration
+            });
             var showEmpty = messages.length === 0 && !showLoader && !isClearing && status !== 'error';
             var DefaultMessage = MessageComponent || MemoizedDefaultMessage;
             var DefaultLoader = LoaderComponent || DefaultLoaderComponent;
             var DefaultError = ErrorComponent || DefaultErrorComponent;
+            // An inline loader needs an assistant message to live in; before the first
+            // response part there is none, so it falls back to its own row.
+            var isLoaderInline = loaderPosition === 'message-inline' && loaderMessage !== undefined;
+            var loaderText = typeof translations.loaderText === 'function' ? translations.loaderText(loaderContext) : translations.loaderText;
+            var loaderElement = showLoader ? /*#__PURE__*/ createElement(DefaultLoader, {
+                context: loaderContext,
+                inline: isLoaderInline,
+                translations: {
+                    loaderText: loaderText
+                }
+            }) : undefined;
+            // Waits for the answer's text and for the loader to step aside, so two
+            // progress affordances never stack up.
+            var showPendingSuggestions = suggestionsLoading && !showLoader && lastMessage !== undefined && hasTextContent(lastMessage);
             return /*#__PURE__*/ createElement("div", _object_spread_props(_object_spread({}, props), {
                 className: cx(cssClasses.root, props.className),
                 role: "log",
-                "aria-live": "polite"
+                "aria-live": "polite",
+                "aria-busy": isProcessing ? 'true' : undefined
             }), /*#__PURE__*/ createElement("div", {
                 className: cx(cssClasses.scroll),
                 ref: scrollRef
@@ -14826,14 +15366,10 @@
                     classNames: messageClassNames,
                     messageTranslations: messageTranslations,
                     context: context,
-                    suggestionsElement: status === 'ready' && message.role === 'assistant' && index === messages.length - 1 ? suggestionsElement : undefined
+                    suggestionsElement: (status === 'ready' || showPendingSuggestions) && message.role === 'assistant' && index === messages.length - 1 ? suggestionsElement : undefined,
+                    loaderElement: isLoaderInline && index === messages.length - 1 ? loaderElement : undefined
                 });
-            }), showLoader && /*#__PURE__*/ createElement(DefaultLoader, {
-                translations: {
-                    loaderText: translations.loaderText
-                },
-                context: context
-            }), status === 'error' && /*#__PURE__*/ createElement(DefaultError, {
+            }), !isLoaderInline && loaderElement, status === 'error' && /*#__PURE__*/ createElement(DefaultError, {
                 onNewConversation: onNewConversation,
                 errorMessage: error === null || error === void 0 ? void 0 : error.message,
                 translations: // `fallbackResponse` that's safe to display verbatim; for
@@ -14860,17 +15396,65 @@
             })));
         };
     }
-    var getShowLoader = function getShowLoader(status, lastPart, tools, showReasoning, hasActiveReasoning) {
+    var getLoaderPhase = function getLoaderPhase(status, message, showReasoning) {
+        if (status === 'submitted') return 'submitted';
+        var lastPart = findLastProgressPart(message === null || message === void 0 ? void 0 : message.parts);
+        if (!lastPart) return 'thinking';
+        if (isPartTool(lastPart)) return 'tool';
+        if (showReasoning && lastPart.type === 'reasoning') return 'reasoning';
+        return 'thinking';
+    };
+    /**
+     * A stable signature of every `shouldRender` verdict in a message, so a memoized
+     * row can be invalidated when a verdict changes. `undefined` when no tool part
+     * in the message declares the predicate.
+     */ var getShouldRenderVerdicts = function getShouldRenderVerdicts(context, message) {
+        var _message_parts;
+        var verdicts;
+        (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.forEach(function(part, index) {
+            var _findTool;
+            if (!isPartTool(part)) {
+                return;
+            }
+            var shouldRender = (_findTool = findTool(part.type, context.tools)) === null || _findTool === void 0 ? void 0 : _findTool.shouldRender;
+            if (!shouldRender) {
+                return;
+            }
+            verdicts = "".concat(verdicts !== null && verdicts !== void 0 ? verdicts : '').concat(index, ":").concat(shouldRender(_object_spread_props(_object_spread({}, context), {
+                message: part,
+                parentMessage: message
+            })), ";");
+        });
+        return verdicts;
+    };
+    var getShowLoader = function getShowLoader(context, showReasoning, hasActiveReasoning) {
+        var status = context.status, messages = context.messages, tools = context.tools;
         if (status !== 'submitted' && status !== 'streaming') return false;
         if (status === 'submitted') return true;
+        var lastMessage = messages[messages.length - 1];
+        // Parts that render nothing must not answer for the turn's progress, or the
+        // loader flips on a part that changed nothing on screen.
+        var lastPart = findLastProgressPart(lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.parts);
         if (!lastPart) return true;
         // An active disclosure carries its own progress affordance, so the loader would
         // double it. Settled reasoning still shows it: the answer has not started.
         if (showReasoning && hasActiveReasoning) return false;
         if (isPartText(lastPart)) return false;
-        if (isPartTool(lastPart) && lastPart.state === 'input-streaming') {
+        if (isPartTool(lastPart)) {
+            var _tool_shouldRender;
             var tool = findTool(lastPart.type, tools);
-            return !(tool === null || tool === void 0 ? void 0 : tool.streamInput);
+            // A part the tool declines to render leaves nothing on screen, so the turn
+            // still reads as in progress — keep the loader up rather than letting a
+            // settled-but-hidden part terminate it.
+            if (lastMessage && (tool === null || tool === void 0 ? void 0 : (_tool_shouldRender = tool.shouldRender) === null || _tool_shouldRender === void 0 ? void 0 : _tool_shouldRender.call(tool, _object_spread_props(_object_spread({}, context), {
+                message: lastPart,
+                parentMessage: lastMessage
+            }))) === false) {
+                return true;
+            }
+            if (lastPart.state === 'input-streaming') {
+                return !(tool === null || tool === void 0 ? void 0 : tool.streamInput);
+            }
         }
         return true;
     };
@@ -15086,20 +15670,31 @@
             createElement: createElement
         });
         return function ChatPromptSuggestions(userProps) {
-            var _userProps_suggestions = userProps.suggestions, suggestions = _userProps_suggestions === void 0 ? [] : _userProps_suggestions, onSuggestionClick = userProps.onSuggestionClick, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
-            if (suggestions.length === 0) {
+            var _userProps_suggestions = userProps.suggestions, suggestions = _userProps_suggestions === void 0 ? [] : _userProps_suggestions, onSuggestionClick = userProps.onSuggestionClick, _userProps_isLoading = userProps.isLoading, isLoading = _userProps_isLoading === void 0 ? false : _userProps_isLoading, _userProps_skeletonCount = userProps.skeletonCount, skeletonCount = _userProps_skeletonCount === void 0 ? 3 : _userProps_skeletonCount, _userProps_classNames = userProps.classNames, classNames = _userProps_classNames === void 0 ? {} : _userProps_classNames;
+            var visibleSuggestions = suggestions.filter(function(suggestion) {
+                return suggestion.trim() !== '';
+            });
+            if (visibleSuggestions.length === 0 && !isLoading) {
                 return null;
             }
             return /*#__PURE__*/ createElement("div", {
                 className: cx('ais-ChatPromptSuggestions', classNames.root)
-            }, suggestions.map(function(suggestion, index) {
+            }, isLoading && visibleSuggestions.length === 0 ? _to_consumable_array(new Array(skeletonCount)).map(function(_, index) {
+                return /*#__PURE__*/ createElement("div", {
+                    key: index,
+                    className: cx('ais-ChatPromptSuggestions-skeletonItem', classNames.skeletonItem)
+                });
+            }) : visibleSuggestions.map(function(suggestion, index) {
                 return /*#__PURE__*/ createElement(Button, {
                     key: index,
                     size: "sm",
                     variant: "primary",
                     className: cx('ais-ChatPromptSuggestions-suggestion', classNames.suggestion),
+                    // A half-written suggestion can't be sent. Not `disabled`,
+                    // which would restyle the pill mid-stream.
                     onClick: function onClick() {
-                        return onSuggestionClick(suggestion);
+                        if (isLoading) return;
+                        onSuggestionClick(suggestion);
                     }
                 }, suggestion);
             }));
@@ -15110,7 +15705,7 @@
         return typeof window !== 'undefined' && typeof window.matchMedia === 'function' && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
     }
     function createChatComponent(param) {
-        var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo, useState = param.useState;
+        var createElement = param.createElement, Fragment = param.Fragment, useMemo = param.useMemo, useState = param.useState, useEffect = param.useEffect;
         var ChatHeader = createChatHeaderComponent({
             createElement: createElement,
             Fragment: Fragment
@@ -15118,7 +15713,9 @@
         var ChatMessages = createChatMessagesComponent({
             createElement: createElement,
             Fragment: Fragment,
-            useMemo: useMemo
+            useMemo: useMemo,
+            useState: useState,
+            useEffect: useEffect
         });
         var ChatPrompt = createChatPromptComponent({
             createElement: createElement,
@@ -15190,6 +15787,7 @@
                 error: error,
                 classNames: classNames.messages,
                 messageClassNames: classNames.message,
+                suggestionsLoading: suggestionsProps.isLoading,
                 suggestionsElement: createElement(SuggestionsComponent || ChatPromptSuggestions, _object_spread_props(_object_spread({}, suggestionsProps), {
                     classNames: classNames.suggestions
                 }))
@@ -15495,7 +16093,7 @@
             createElement: createElement
         });
         return function HeaderComponent(param) {
-            var showViewAll = param.showViewAll, canScrollLeft = param.canScrollLeft, canScrollRight = param.canScrollRight, scrollLeft = param.scrollLeft, scrollRight = param.scrollRight, nbHits = param.nbHits, input = param.input, nbItems = param.nbItems, applyFilters = param.applyFilters, getSearchPageURL = param.getSearchPageURL, onClose = param.onClose;
+            var showViewAll = param.showViewAll, canScrollLeft = param.canScrollLeft, canScrollRight = param.canScrollRight, scrollLeft = param.scrollLeft, scrollRight = param.scrollRight, nbHits = param.nbHits, input = param.input, resolvedSearchParams = param.resolvedSearchParams, nbItems = param.nbItems, applyFilters = param.applyFilters, getSearchPageURL = param.getSearchPageURL, onClose = param.onClose;
             if (nbItems < 1) {
                 return null;
             }
@@ -15510,7 +16108,7 @@
                 size: "sm",
                 onClick: function onClick() {
                     if (!input || !applyFilters) return;
-                    var params = applyFilters(getApplyFiltersParamsFromToolInput(input));
+                    var params = applyFilters(getApplyFiltersParamsFromToolInput(input, resolvedSearchParams));
                     if (getSearchPageURL) {
                         var searchPageURL = getSearchPageURL(params);
                         var resolvedURL = new URL(searchPageURL, window.location.href);
@@ -15564,6 +16162,14 @@
             var message = context.message, applyFilters = context.applyFilters, insightsEventContext = context.insightsEventContext, sendEvent = context.sendEvent, onClose = context.onClose;
             var instantSearchStatus = (_ref = insightsEventContext === null || insightsEventContext === void 0 ? void 0 : insightsEventContext.instantSearchStatus) !== null && _ref !== void 0 ? _ref : 'idle';
             var input = message === null || message === void 0 ? void 0 : message.input;
+            // What the server actually searched with, when it sent it. Absent for the
+            // default search tool and whenever the MCP server emits no `_meta`.
+            var resolvedSearchParams = useMemo(function() {
+                return getResolvedSearchParams(context.messages, message === null || message === void 0 ? void 0 : message.toolCallId);
+            }, [
+                context.messages,
+                message === null || message === void 0 ? void 0 : message.toolCallId
+            ]);
             var output = message === null || message === void 0 ? void 0 : message.output;
             var hits = (output === null || output === void 0 ? void 0 : output.hits) || [];
             var items = addQueryID(addAbsolutePosition(hits, 0, hits.length), output === null || output === void 0 ? void 0 : output.queryID);
@@ -15611,6 +16217,7 @@
                             showViewAll: showViewAll,
                             nbHits: output === null || output === void 0 ? void 0 : output.nbHits,
                             input: input,
+                            resolvedSearchParams: resolvedSearchParams,
                             applyFilters: applyFilters,
                             getSearchPageURL: getSearchPageURL,
                             onClose: onClose
@@ -15622,6 +16229,7 @@
                         showViewAll: showViewAll,
                         nbHits: output === null || output === void 0 ? void 0 : output.nbHits,
                         input: input,
+                        resolvedSearchParams: resolvedSearchParams,
                         applyFilters: applyFilters,
                         getSearchPageURL: getSearchPageURL,
                         onClose: onClose
@@ -15632,6 +16240,7 @@
                 HeaderComponent,
                 output === null || output === void 0 ? void 0 : output.nbHits,
                 input,
+                resolvedSearchParams,
                 applyFilters,
                 getSearchPageURL,
                 onClose
@@ -18760,6 +19369,13 @@
     var MemorySearchToolType = 'algolia_memory_search';
     var PonderToolType = 'algolia_ponder';
     var DisplayResultsToolType = 'algolia_display_results';
+    /**
+     * Whether `toolName` is the search tool as the Algolia MCP Server exposes it:
+     * one tool per index, named after the index it searches
+     * (`algolia_search_index_products`).
+     */ var matchesSearchIndexToolName = function matchesSearchIndexToolName(toolName) {
+        return toolName.startsWith("".concat(SearchIndexToolType, "_"));
+    };
 
     function flat(arr) {
         return arr.reduce(function(acc, array) {
@@ -19019,6 +19635,11 @@
             return refinement.attribute;
         }));
     }
+    /**
+     * One Algolia `numericFilters` entry: `'price <= 1500'`. The operators are
+     * exactly the set `helper.addNumericRefinement` accepts, and exactly the set
+     * the Algolia MCP Server emits.
+     */ var NUMERIC_FILTER = /^(.+?)\s*(<=|>=|!=|=|<|>)\s*(-?\d+(?:\.\d+)?)$/;
     function updateStateFromSearchToolInput(params, helper) {
         // clear all filters first
         var attributesToClear = getAttributesToClear$1({
@@ -19062,6 +19683,16 @@
                 helper.toggleFacetRefinement(name, value);
             });
         }
+        if (params.numericFilters) {
+            params.numericFilters.forEach(function(filter) {
+                var match = filter.match(NUMERIC_FILTER);
+                if (!match) {
+                    return;
+                }
+                var _match = _sliced_to_array(match, 4), attribute = _match[1], operator = _match[2], value = _match[3];
+                helper.addNumericRefinement(attribute, operator, Number(value));
+            });
+        }
         if (params.query) {
             helper.setQuery(params.query);
         }
@@ -19072,7 +19703,7 @@
         var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
         checkRendering(renderFn, withUsage$q());
         return function(widgetParams) {
-            var _ref = widgetParams || {}, _ref_resume = _ref.resume, resume = _ref_resume === void 0 ? false : _ref_resume, _ref_tools = _ref.tools, tools = _ref_tools === void 0 ? {} : _ref_tools, _ref_type = _ref.type, type = _ref_type === void 0 ? 'chat' : _ref_type, persistence = _ref.persistence, context = _ref.context, initialUserMessage = _ref.initialUserMessage, initialMessages = _ref.initialMessages, _ref_disableTriggerValidation = _ref.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, _ref_sendAutomaticallyWhen = _ref.sendAutomaticallyWhen, sendAutomaticallyWhen = _ref_sendAutomaticallyWhen === void 0 ? lastAssistantMessageIsCompleteWithToolCalls : _ref_sendAutomaticallyWhen, _ref_requiresSearch = _ref.requiresSearch, requiresSearch = _ref_requiresSearch === void 0 ? true : _ref_requiresSearch, options = _object_without_properties(_ref, [
+            var _ref = widgetParams || {}, _ref_resume = _ref.resume, resume = _ref_resume === void 0 ? false : _ref_resume, tmp = _ref.tools, tools_ = tmp === void 0 ? {} : tmp, _ref_type = _ref.type, type = _ref_type === void 0 ? 'chat' : _ref_type, persistence = _ref.persistence, context = _ref.context, initialUserMessage = _ref.initialUserMessage, initialMessages = _ref.initialMessages, _ref_disableTriggerValidation = _ref.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, _ref_sendAutomaticallyWhen = _ref.sendAutomaticallyWhen, sendAutomaticallyWhen = _ref_sendAutomaticallyWhen === void 0 ? lastAssistantMessageIsCompleteWithToolCalls : _ref_sendAutomaticallyWhen, _ref_requiresSearch = _ref.requiresSearch, requiresSearch = _ref_requiresSearch === void 0 ? true : _ref_requiresSearch, options = _object_without_properties(_ref, [
                 "resume",
                 "tools",
                 "type",
@@ -19085,11 +19716,12 @@
                 "requiresSearch"
             ]);
             var normalizedPersistence = normalizePersistence(persistence, 'chat' in options);
-            // Compatibility shim with Algolia MCP Server search tool, which suffixes
-            // the tool name with the index name (`searchIndex_products`).
-            var resolveTool = function resolveTool(toolName) {
-                return tools[toolName] || (toolName.startsWith("".concat(SearchIndexToolType, "_")) ? tools[SearchIndexToolType] : undefined);
-            };
+            // The Algolia MCP Server exposes the search tool once per index and names
+            // it after the index (`algolia_search_index_products`). A `matchesToolName`
+            // set by the user wins, as does a tool registered under the derived name.
+            var tools = tools_[SearchIndexToolType] && tools_[SearchIndexToolType].matchesToolName === undefined ? _object_spread_props(_object_spread({}, tools_), _define_property({}, SearchIndexToolType, _object_spread_props(_object_spread({}, tools_[SearchIndexToolType]), {
+                matchesToolName: matchesSearchIndexToolName
+            }))) : tools_;
             var _chatInstance;
             var input = '';
             var open = false;
@@ -19117,21 +19749,44 @@
                     return unsubscribe();
                 });
             };
-            // Extract suggestions from the last assistant message's data-suggestions part
-            var getSuggestionsFromMessages = function getSuggestionsFromMessages(messages) {
-                // Find the last assistant message (iterate from end)
-                var lastAssistantMessage = _to_consumable_array(messages).reverse().find(function(message) {
+            var findSuggestionsPart = function findSuggestionsPart(message) {
+                var _message_parts;
+                return message === null || message === void 0 ? void 0 : (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.find(function(part) {
+                    var _part_data;
+                    return 'type' in part && part.type === 'data-suggestions' && 'data' in part && Array.isArray((_part_data = part.data) === null || _part_data === void 0 ? void 0 : _part_data.suggestions);
+                });
+            };
+            var findLastAssistantMessage = function findLastAssistantMessage(messages) {
+                return _to_consumable_array(messages).reverse().find(function(message) {
                     return message.role === 'assistant' && message.parts;
                 });
-                if (!(lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : lastAssistantMessage.parts)) {
-                    return undefined;
+            };
+            // Extract suggestions from the last assistant message's data-suggestions part
+            var getSuggestionsFromMessages = function getSuggestionsFromMessages(messages) {
+                var _findSuggestionsPart;
+                return (_findSuggestionsPart = findSuggestionsPart(findLastAssistantMessage(messages))) === null || _findSuggestionsPart === void 0 ? void 0 : _findSuggestionsPart.data.suggestions;
+            };
+            // "Still coming" has to be inferred: the turn is running and has no
+            // `data-suggestions` part yet. Expecting any at all needs evidence, or an
+            // agent that never sends them would sit under a placeholder forever.
+            var getSuggestionsStatus = function getSuggestionsStatus(messages) {
+                var _lastAssistantMessage_metadata;
+                var status = _chatInstance.status;
+                if (status !== 'submitted' && status !== 'streaming') {
+                    return 'idle';
                 }
-                // Find the data-suggestions part
-                var suggestionsPart = lastAssistantMessage.parts.find(function(part) {
-                    var _part_data;
-                    return 'type' in part && part.type === 'data-suggestions' && 'data' in part && Array.isArray((_part_data = part.data) === null || _part_data === void 0 ? void 0 : _part_data.suggestions);
+                var lastAssistantMessage = findLastAssistantMessage(messages);
+                if (findSuggestionsPart(lastAssistantMessage)) {
+                    return 'idle';
+                }
+                var declaresSuggestions = (lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : (_lastAssistantMessage_metadata = lastAssistantMessage.metadata) === null || _lastAssistantMessage_metadata === void 0 ? void 0 : _lastAssistantMessage_metadata.suggestionsEnabled) === true;
+                if (declaresSuggestions) {
+                    return 'loading';
+                }
+                var hasSuggestionsHistory = messages.some(function(message) {
+                    return message !== lastAssistantMessage && message.role === 'assistant' && Boolean(findSuggestionsPart(message));
                 });
-                return suggestionsPart === null || suggestionsPart === void 0 ? void 0 : suggestionsPart.data.suggestions;
+                return hasSuggestionsHistory ? 'loading' : 'idle';
             };
             var setMessages = function setMessages(messagesParam) {
                 if (typeof messagesParam === 'function') {
@@ -19274,14 +19929,14 @@
                     sendAutomaticallyWhen: sendAutomaticallyWhen,
                     transport: transport,
                     shouldRepairToolInput: function shouldRepairToolInput(toolName) {
-                        var tool = resolveTool(toolName);
+                        var tool = findTool(toolName, tools);
                         if (!tool) return true;
                         return Boolean(tool.streamInput);
                     },
                     resolveCancelledToolOutput: function resolveCancelledToolOutput(param) {
                         var toolName = param.toolName, toolCallId = param.toolCallId, input = param.input;
-                        var _resolveTool;
-                        var cancelOutput = (_resolveTool = resolveTool(toolName)) === null || _resolveTool === void 0 ? void 0 : _resolveTool.cancelOutput;
+                        var _findTool;
+                        var cancelOutput = (_findTool = findTool(toolName, tools)) === null || _findTool === void 0 ? void 0 : _findTool.cancelOutput;
                         if (!cancelOutput) return undefined;
                         try {
                             var output = cancelOutput({
@@ -19298,7 +19953,7 @@
                     },
                     onToolCall: function onToolCall(param, submitToolResult) {
                         var toolCall = param.toolCall;
-                        var tool = resolveTool(toolCall.toolName);
+                        var tool = findTool(toolCall.toolName, tools);
                         if (!tool) {
                             return submitToolResult({
                                 output: 'No tool implemented for "'.concat(toolCall.toolName, '".'),
@@ -19348,7 +20003,8 @@
                         // `open` is read by sibling widgets (e.g. `chatTrigger`) via the
                         // shared `renderState`. Schedule a full re-render so they pick up
                         // the new value instead of staying frozen on their initial state.
-                        initOptions.instantSearchInstance.scheduleRender();
+                        // No search runs here, so it must not settle the main search.
+                        initOptions.instantSearchInstance.scheduleRender(false);
                     };
                     setOpen = function setOpen(nextOpen) {
                         updateOpen(nextOpen, nextOpen && !open);
@@ -19401,14 +20057,15 @@
                     // disable themselves, so a transition has to escape this widget's own
                     // render. Message deltas deliberately don't: they stay local to keep
                     // streaming cheap. The `status` setter notifies on every write, hence
-                    // the comparison.
+                    // the comparison. A chat turn is not a search, so the render it
+                    // schedules must not settle the main search.
                     var lastStatus = _chatInstance.status;
                     var renderOnStatusChange = function renderOnStatusChange() {
                         var statusChanged = _chatInstance.status !== lastStatus;
                         lastStatus = _chatInstance.status;
                         render();
                         if (statusChanged) {
-                            initOptions.instantSearchInstance.scheduleRender();
+                            initOptions.instantSearchInstance.scheduleRender(false);
                         }
                     };
                     safelyRunOnBrowser(function() {
@@ -19438,8 +20095,10 @@
                     renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
                         instantSearchInstance: instantSearchInstance
                     }), true);
+                    // A restored open panel is new to the sibling entry points, but it is
+                    // not a search result.
                     if (open) {
-                        instantSearchInstance.scheduleRender();
+                        instantSearchInstance.scheduleRender(false);
                     }
                 },
                 render: function render(renderOptions) {
@@ -19528,6 +20187,7 @@
                         '~isOpenStatePersistenceEnabled': normalizedPersistence.open,
                         setMessages: setMessages,
                         suggestions: getSuggestionsFromMessages(_chatInstance.messages),
+                        suggestionsStatus: getSuggestionsStatus(_chatInstance.messages),
                         clearMessages: clearMessages,
                         tools: toolsWithAddToolResult,
                         records: records,
@@ -19605,7 +20265,11 @@
 
     function useChat(props, additionalWidgetProperties) {
         var isHydrated = useIsHydrated();
+        React.useRef(props);
+        React.useRef(null);
+        useIsomorphicLayoutEffect(function() {});
         var chatState = useConnector(connectChat, props, additionalWidgetProperties);
+        useIsomorphicLayoutEffect(function() {});
         if (isHydrated) {
             return chatState;
         }
@@ -19631,120 +20295,333 @@
         });
     }
 
-    function buildEndpoint(param) {
-        var appId = param.appId, agentId = param.agentId;
-        return "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/tasks");
+    function isHeaders$1(headers) {
+        return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
     }
-    function resolveEndpoint(params) {
-        if (params.transport) {
-            return {
-                endpoint: params.transport.api,
-                headers: params.transport.headers || {},
-                prepareSendMessagesRequest: params.transport.prepareSendMessagesRequest
-            };
+    function headersToRecord$1(headers) {
+        if (!headers) {
+            return {};
         }
-        if (!params.appId || !params.apiKey || !params.agentId) {
-            throw new Error('[tasks] Either `transport` or `{ appId, apiKey, agentId }` is required.');
+        if (isHeaders$1(headers)) {
+            return Object.fromEntries(headers.entries());
         }
-        var headers = {
-            'x-algolia-application-id': params.appId,
-            'x-algolia-api-key': params.apiKey
-        };
-        if (params.algoliaAgent) {
-            headers['x-algolia-agent'] = "".concat(params.algoliaAgent, "; tasks");
+        if (Array.isArray(headers)) {
+            return Object.fromEntries(headers);
         }
-        return {
-            endpoint: buildEndpoint({
-                appId: params.appId,
-                agentId: params.agentId
-            }),
-            headers: headers
-        };
+        return headers;
     }
-
-    function buildTaskPayload(param) {
-        var task = param.task, input = param.input, prepareRequest = param.prepareRequest;
-        var payload = {
-            task: task,
-            input: input
-        };
-        return prepareRequest ? prepareRequest(payload).body : payload;
+    function withJsonContentType(headers) {
+        var merged = _object_spread({}, headersToRecord$1(headers));
+        Object.keys(merged).forEach(function(name) {
+            if (name.toLowerCase() === 'content-type') {
+                delete merged[name];
+            }
+        });
+        merged['Content-Type'] = 'application/json';
+        return merged;
     }
     function withStreamParam(url) {
         return url.includes('?') ? "".concat(url, "&stream=true") : "".concat(url, "?stream=true");
     }
-    function resolveStreamedOutput(data, previous) {
-        return typeof data === 'string' ? parsePartialJson(data, previous) : data;
+    function createTaskPreparationContext(context) {
+        function hideProperty(key) {
+            var value = context[key];
+            Object.defineProperty(context, key, {
+                configurable: true,
+                enumerable: false,
+                get: function get() {
+                    return value;
+                },
+                set: function set(nextValue) {
+                    Reflect.deleteProperty(context, key);
+                    Object.defineProperty(context, key, {
+                        configurable: true,
+                        enumerable: true,
+                        value: nextValue,
+                        writable: true
+                    });
+                }
+            });
+        }
+        // Rich metadata stays out of legacy body spreads until assigned as payload.
+        hideProperty('stream');
+        hideProperty('body');
+        hideProperty('credentials');
+        hideProperty('headers');
+        hideProperty('api');
+        return context;
     }
-    function consumeTaskStream(body, onData) {
+    function unwrap(envelope) {
+        if ((typeof envelope === "undefined" ? "undefined" : _type_of(envelope)) === 'object' && envelope !== null && 'output' in envelope) {
+            return envelope.output;
+        }
+        return undefined;
+    }
+    function consumeTaskTextStream(body, onData) {
         return new Promise(function(resolve, reject) {
-            var chunkStream = parseJsonEventStream(body);
+            var decoder = new TextDecoder();
+            var reader = body.getReader();
+            var accumulatedText = '';
             var latest;
-            processStream(chunkStream, function(chunk) {
-                if (!chunk) {
-                    return;
+            var publish = function publish(output) {
+                if (!isEqual(output, latest)) {
+                    latest = output;
+                    onData === null || onData === void 0 ? void 0 : onData({
+                        output: output
+                    });
                 }
-                // A terminal `error` event aborts the task: reject rather than let the
-                // stream close and resolve the last partial snapshot as a success.
-                // Throwing here lets `processStream` release the reader and stop
-                // consuming; the rejection propagates to the caller's `.catch`.
-                if (chunk.type === 'error') {
-                    throw new Error(chunk.errorText || 'Task stream error');
+            };
+            var read = function read1() {
+                reader.read().then(function(param) {
+                    var done = param.done, value = param.value;
+                    if (done) {
+                        accumulatedText += decoder.decode();
+                        reader.releaseLock();
+                        try {
+                            var output = JSON.parse(accumulatedText);
+                            publish(output);
+                            resolve({
+                                output: output
+                            });
+                        } catch (error) {
+                            reject(error);
+                        }
+                        return;
+                    }
+                    try {
+                        accumulatedText += decoder.decode(value, {
+                            stream: true
+                        });
+                        var partial = parsePartialJson(accumulatedText, latest);
+                        if (partial !== undefined) {
+                            publish(partial);
+                        }
+                        read();
+                    } catch (error) {
+                        reader.releaseLock();
+                        reject(error);
+                    }
+                }, function(error) {
+                    reader.releaseLock();
+                    reject(error);
+                });
+            };
+            read();
+        });
+    }
+    /** Default HTTP transport for named Tasks requests and task-output streams. */ var DefaultTaskTransport = /*#__PURE__*/ function() {
+        function DefaultTaskTransport() {
+            var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_api = _ref.api, api = _ref_api === void 0 ? '/api/tasks' : _ref_api, credentials = _ref.credentials, headers = _ref.headers, body = _ref.body, customFetch = _ref.fetch, prepareSendMessagesRequest = _ref.prepareSendMessagesRequest;
+            _class_call_check(this, DefaultTaskTransport);
+            _define_property(this, "api", void 0);
+            _define_property(this, "credentials", void 0);
+            _define_property(this, "headers", void 0);
+            _define_property(this, "body", void 0);
+            _define_property(this, "fetch", void 0);
+            _define_property(this, "prepareSendMessagesRequest", void 0);
+            this.api = api;
+            this.credentials = credentials;
+            this.headers = headers;
+            this.body = body;
+            this.fetch = customFetch;
+            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+        }
+        _create_class(DefaultTaskTransport, [
+            {
+                key: "sendTask",
+                value: function sendTask(param) {
+                    var task = param.task, kind = param.kind, input = param.input, stream = param.stream, onData = param.onData;
+                    return this.sendTaskRequest({
+                        task: task,
+                        kind: kind,
+                        input: input,
+                        stream: stream,
+                        onData: onData ? function(data) {
+                            return onData(unwrap(data));
+                        } : undefined
+                    }).then(unwrap);
                 }
-                if (chunk.type !== 'data-task-output') {
-                    return;
+            },
+            {
+                /** @internal */ key: "sendTaskRequest",
+                value: function sendTaskRequest(param) {
+                    var _this = this;
+                    var task = param.task, kind = param.kind, input = param.input, stream = param.stream, onData = param.onData;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    return Promise.all([
+                        resolveValue(this.credentials),
+                        resolveValue(this.headers),
+                        resolveValue(this.body)
+                    ]).then(function(param) {
+                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
+                        var api = _this.api;
+                        var credentials = resolvedCredentials;
+                        var headers = withJsonContentType(resolvedHeaders);
+                        var body = _object_spread(_object_spread_props(_object_spread({}, task === undefined ? {} : {
+                            task: task
+                        }, kind === undefined ? {} : {
+                            kind: kind
+                        }), {
+                            input: input
+                        }), resolvedBody);
+                        var preparedBody = resolvedBody ? _object_spread({}, resolvedBody) : undefined;
+                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest(createTaskPreparationContext({
+                            task: task,
+                            kind: kind,
+                            input: input,
+                            stream: stream,
+                            body: preparedBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api
+                        }))) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                body = prepared.body;
+                                if (prepared.api) {
+                                    api = prepared.api;
+                                }
+                                if (prepared.credentials) {
+                                    credentials = prepared.credentials;
+                                }
+                                if (prepared.headers) {
+                                    headers = withJsonContentType(prepared.headers);
+                                }
+                            }
+                            var request = {
+                                method: 'POST',
+                                headers: headers,
+                                body: JSON.stringify(body)
+                            };
+                            if (credentials !== undefined) {
+                                request.credentials = credentials;
+                            }
+                            return fetchFn(stream ? withStreamParam(api) : api, request).then(function(response) {
+                                var _response_headers_get, _response_headers;
+                                if (!response.ok) {
+                                    throw new Error("HTTP error ".concat(response.status));
+                                }
+                                var contentType = ((_response_headers = response.headers) === null || _response_headers === void 0 ? void 0 : (_response_headers_get = _response_headers.get) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.call(_response_headers, 'content-type')) || '';
+                                if (stream && contentType.includes('text/plain')) {
+                                    if (!response.body) {
+                                        throw new Error('Response body is empty');
+                                    }
+                                    return consumeTaskTextStream(response.body, onData);
+                                }
+                                return response.json();
+                            });
+                        });
+                    });
                 }
-                latest = resolveStreamedOutput(chunk.data, latest);
-                if (onData) {
-                    onData(latest);
+            }
+        ]);
+        return DefaultTaskTransport;
+    }();
+
+    function buildEndpoint(param) {
+        var appId = param.appId, agentId = param.agentId;
+        return "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/tasks");
+    }
+    function isHeaders(headers) {
+        return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
+    }
+    function headersToRecord(headers) {
+        if (!headers) {
+            return {};
+        }
+        if (isHeaders(headers)) {
+            return Object.fromEntries(headers.entries());
+        }
+        if (Array.isArray(headers)) {
+            return Object.fromEntries(headers);
+        }
+        return _object_spread({}, headers);
+    }
+    function mergeProtectedHeaders(headers, protectedHeaders) {
+        var merged = headersToRecord(headers);
+        Object.entries(protectedHeaders).forEach(function(param) {
+            var _param = _sliced_to_array(param, 2), protectedName = _param[0], value = _param[1];
+            Object.keys(merged).forEach(function(name) {
+                if (name.toLowerCase() === protectedName.toLowerCase()) {
+                    delete merged[name];
                 }
-            }, function() {
-                return resolve(latest);
-            }, reject);
+            });
+            merged[protectedName] = value;
         });
+        return merged;
     }
-    function fetchTask(param) {
-        var endpoint = param.endpoint, headers = param.headers, payload = param.payload, onData = param.onData, _param_stream = param.stream, stream = _param_stream === void 0 ? true : _param_stream;
-        return fetch(stream ? withStreamParam(endpoint) : endpoint, {
-            method: 'POST',
-            headers: _object_spread_props(_object_spread({}, headers), {
-                'Content-Type': 'application/json'
+    /** @internal */ function createTaskTransport(param) {
+        var _param_transport = param.transport, transport = _param_transport === void 0 ? {} : _param_transport, appId = param.appId, apiKey = param.apiKey, agentId = param.agentId, algoliaAgent = param.algoliaAgent;
+        var _transport_api;
+        if (!agentId) {
+            return new DefaultTaskTransport(transport);
+        }
+        if (!appId || !apiKey) {
+            throw new Error('[tasks] `appId` and `apiKey` are required when `agentId` is provided.');
+        }
+        var protectedHeaders = {
+            'x-algolia-application-id': appId,
+            'x-algolia-api-key': apiKey
+        };
+        if (algoliaAgent) {
+            protectedHeaders['x-algolia-agent'] = "".concat(algoliaAgent, "; tasks");
+        }
+        var originalPrepare = transport.prepareSendMessagesRequest;
+        var prepareSendMessagesRequest = originalPrepare ? function(request) {
+            return Promise.resolve(originalPrepare(request)).then(function(prepared) {
+                return _object_spread_props(_object_spread({}, prepared), {
+                    headers: prepared.headers ? mergeProtectedHeaders(prepared.headers, protectedHeaders) : undefined
+                });
+            });
+        } : undefined;
+        return new DefaultTaskTransport(_object_spread_props(_object_spread({}, transport), {
+            api: (_transport_api = transport.api) !== null && _transport_api !== void 0 ? _transport_api : buildEndpoint({
+                appId: appId,
+                agentId: agentId
             }),
-            body: JSON.stringify(payload)
-        }).then(function(response) {
-            var _response_headers_get, _response_headers;
-            if (!response.ok) {
-                throw new Error("HTTP error ".concat(response.status));
-            }
-            var contentType = ((_response_headers = response.headers) === null || _response_headers === void 0 ? void 0 : (_response_headers_get = _response_headers.get) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.call(_response_headers, 'content-type')) || '';
-            if (stream && response.body && contentType.includes('text/event-stream')) {
-                return consumeTaskStream(response.body, onData);
-            }
-            return response.json();
-        });
-    }
-    function unwrap(envelope) {
-        return envelope === null || envelope === void 0 ? void 0 : envelope.output;
+            headers: function headers() {
+                return Promise.resolve(resolveValue(transport.headers)).then(function(headers) {
+                    return mergeProtectedHeaders(headers, protectedHeaders);
+                });
+            },
+            prepareSendMessagesRequest: prepareSendMessagesRequest
+        }));
     }
-    function createTaskRunner(param) {
-        var endpoint = param.endpoint, headers = param.headers, task = param.task, _param_stream = param.stream, stream = _param_stream === void 0 ? true : _param_stream, prepareRequest = param.prepareRequest;
+
+    function createTaskRunner(options) {
+        var task = options.task, kind = options.kind, _options_stream = options.stream, stream = _options_stream === void 0 ? true : _options_stream;
+        var transport;
+        if (options.transport !== undefined) {
+            transport = options.transport;
+        } else {
+            var prepareRequest = options.prepareRequest;
+            transport = new DefaultTaskTransport({
+                api: options.endpoint,
+                headers: options.headers,
+                fetch: options.fetch,
+                prepareSendMessagesRequest: prepareRequest ? function(param) {
+                    var requestTask = param.task, requestKind = param.kind, input = param.input;
+                    return prepareRequest(_object_spread_props(_object_spread({}, requestTask === undefined ? {} : {
+                        task: requestTask
+                    }, requestKind === undefined ? {} : {
+                        kind: requestKind
+                    }), {
+                        input: input
+                    }));
+                } : undefined
+            });
+        }
         return {
-            submit: function submit(variables) {
+            submit: function submit(input) {
                 var onData = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}).onData;
-                var payload = buildTaskPayload({
+                return transport.sendTask({
                     task: task,
-                    input: variables,
-                    prepareRequest: prepareRequest
-                });
-                return fetchTask({
-                    endpoint: endpoint,
-                    headers: headers,
-                    payload: payload,
+                    kind: kind,
+                    input: input,
                     stream: stream,
-                    onData: onData ? function(partial) {
-                        return onData(unwrap(partial));
-                    } : undefined
-                }).then(unwrap);
+                    onData: onData
+                });
             }
         };
     }
@@ -19757,12 +20634,12 @@
         var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
         checkRendering(renderFn, withUsage$p());
         return function(widgetParams) {
-            var agentId = widgetParams.agentId, transport = widgetParams.transport, task = widgetParams.task, _widgetParams_stream = widgetParams.stream, stream = _widgetParams_stream === void 0 ? true : _widgetParams_stream;
+            var agentId = widgetParams.agentId, transport = widgetParams.transport, task = widgetParams.task, kind = widgetParams.kind, _widgetParams_stream = widgetParams.stream, stream = _widgetParams_stream === void 0 ? true : _widgetParams_stream;
             if (!agentId && !transport) {
                 throw new Error(withUsage$p('The `agentId` option is required unless a custom `transport` is provided.'));
             }
-            if (!task) {
-                throw new Error(withUsage$p('The `task` option is required.'));
+            if (!task && !kind) {
+                throw new Error(withUsage$p('Either the `task` or `kind` option is required.'));
             }
             var runner;
             var output;
@@ -19814,6 +20691,8 @@
                 // Bump the request id so any in-flight request's callbacks see
                 // `isStale()` and are ignored. The fetch itself is left to complete.
                 requestId += 1;
+                output = undefined;
+                error = undefined;
                 isLoading = false;
                 triggerRender();
             };
@@ -19831,32 +20710,31 @@
                 $$type: 'ais.tasks',
                 init: function init(initOptions) {
                     var instantSearchInstance = initOptions.instantSearchInstance;
-                    if (transport) {
-                        var resolved = resolveEndpoint({
-                            transport: transport
-                        });
-                        runner = createTaskRunner({
-                            endpoint: resolved.endpoint,
-                            headers: resolved.headers,
-                            task: task,
-                            stream: stream,
-                            prepareRequest: resolved.prepareSendMessagesRequest
-                        });
-                    } else {
+                    if (agentId) {
                         var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
                         if (!appId || !apiKey) {
                             throw new Error(withUsage$p('Could not extract Algolia credentials from the search client.'));
                         }
-                        var resolved1 = resolveEndpoint({
+                        var taskTransport = createTaskTransport({
+                            transport: transport,
                             appId: appId,
                             apiKey: apiKey,
                             agentId: agentId,
                             algoliaAgent: getAlgoliaAgent(instantSearchInstance.client)
                         });
                         runner = createTaskRunner({
-                            endpoint: resolved1.endpoint,
-                            headers: resolved1.headers,
+                            transport: taskTransport,
+                            task: task,
+                            kind: kind,
+                            stream: stream
+                        });
+                    } else {
+                        runner = createTaskRunner({
+                            transport: createTaskTransport({
+                                transport: transport
+                            }),
                             task: task,
+                            kind: kind,
                             stream: stream
                         });
                     }
@@ -19888,6 +20766,7 @@
     });
     var RENDER_STATE_KEY = 'promptSuggestions';
     var CHAT_RENDER_STATE_KEY = 'chat';
+    var PROMPT_SUGGESTIONS_TASK_KIND = 'prompt_suggestions';
     var DEBOUNCE_MS = 300;
     function parseSuggestions(data) {
         var suggestions = data === null || data === void 0 ? void 0 : data.suggestions;
@@ -19959,12 +20838,10 @@
             if (!agentId && !transport) {
                 throw new Error(withUsage$o('The `agentId` option is required unless a custom `transport` is provided.'));
             }
-            if (!configurationId) {
-                throw new Error(withUsage$o('The `configurationId` option is required.'));
-            }
             var tasksState;
             var suggestions = [];
             var isLoading = false;
+            var error;
             var debounceTimer;
             var lastStateSignature = null;
             var latestRenderOptions = null;
@@ -20097,6 +20974,7 @@
                 return {
                     suggestions: transformed,
                     isLoading: isLoading,
+                    error: error,
                     onSuggestionClick: send,
                     sendToChat: send,
                     refresh: refresh,
@@ -20109,10 +20987,10 @@
             var handleInnerRender = function handleInnerRender(renderState) {
                 tasksState = renderState;
                 if (refetchPending) return;
+                error = renderState.error;
                 if (renderState.error) {
                     // A failed task (including a mid-stream `error` event) must not leave
-                    // any streamed partial visible. There's no error UI for now, so fall
-                    // back to a blank suggestions state.
+                    // any streamed partial visible.
                     suggestions = [];
                 } else if (renderState.isLoading || renderState.output !== undefined) {
                     // Only adopt the inner output once a request is loading or has
@@ -20123,14 +21001,26 @@
                 if (!latestRenderOptions) return;
                 renderOutward(latestRenderOptions);
             };
-            var tasksWidget = connectTasks(handleInnerRender, noop)(_object_spread_props(_object_spread({}, transport ? {
-                transport: transport
-            } : {
-                agentId: agentId
-            }), {
-                task: configurationId,
-                stream: true
-            }));
+            var tasksParams;
+            if (agentId) {
+                tasksParams = {
+                    agentId: agentId,
+                    transport: transport,
+                    task: configurationId,
+                    kind: PROMPT_SUGGESTIONS_TASK_KIND,
+                    stream: true
+                };
+            } else if (transport) {
+                tasksParams = {
+                    transport: transport,
+                    task: configurationId,
+                    kind: PROMPT_SUGGESTIONS_TASK_KIND,
+                    stream: true
+                };
+            } else {
+                throw new Error(withUsage$o('The `agentId` option is required unless a custom `transport` is provided.'));
+            }
+            var tasksWidget = connectTasks(handleInnerRender, noop)(tasksParams);
             return {
                 $$type: 'ais.promptSuggestions',
                 init: function init(initOptions) {
@@ -20153,6 +21043,7 @@
                     if (stateSignature !== lastStateSignature) {
                         lastStateSignature = stateSignature;
                         refetchPending = true;
+                        error = undefined;
                         clearTimeout(debounceTimer);
                         debounceTimer = setTimeout(function() {
                             if (latestRenderOptions === null || latestRenderOptions === void 0 ? void 0 : latestRenderOptions.results) {
@@ -25431,6 +26322,202 @@
         return /*#__PURE__*/ React.createElement(Breadcrumb$1, _object_spread({}, props, uiProps));
     }
 
+    var containersHeldInert = new WeakSet();
+    var revealAnimationsHeldByContainer = new WeakMap();
+    function getContainer(prompt) {
+        var _ref;
+        return (_ref = prompt === null || prompt === void 0 ? void 0 : prompt.closest('.ais-Chat-container')) !== null && _ref !== void 0 ? _ref : null;
+    }
+    function getActiveContainerAnimations(prompt) {
+        return getActiveAnimations(getContainer(prompt));
+    }
+    function getActiveAnimations(container) {
+        if (!container || typeof container.getAnimations !== 'function') {
+            return [];
+        }
+        return container.getAnimations().filter(function(animation) {
+            return animation.playState !== 'finished';
+        }).map(function(animation) {
+            return {
+                animation: animation,
+                currentTime: animation.currentTime,
+                playState: animation.playState,
+                startTime: animation.startTime
+            };
+        });
+    }
+    var revealProperties = [
+        'opacity',
+        'transform',
+        'translate',
+        'scale',
+        'rotate',
+        'visibility',
+        'clip',
+        'clipPath'
+    ];
+    function isRevealed(style, property) {
+        if (property === 'opacity') {
+            return style.opacity === '1';
+        }
+        if (property === 'transform') {
+            return [
+                'none',
+                'matrix(1, 0, 0, 1, 0, 0)',
+                'matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)'
+            ].includes(style.transform);
+        }
+        if (property === 'translate') {
+            return [
+                'none',
+                '0px',
+                '0px 0px',
+                '0px 0px 0px'
+            ].includes(style.translate);
+        }
+        if (property === 'scale') {
+            return [
+                'none',
+                '1',
+                '1 1'
+            ].includes(style.scale);
+        }
+        if (property === 'rotate') {
+            return [
+                'none',
+                '0deg'
+            ].includes(style.rotate);
+        }
+        if (property === 'visibility') {
+            return style.visibility === 'visible';
+        }
+        if (property === 'clip') {
+            return [
+                'auto',
+                'rect(auto, auto, auto, auto)'
+            ].includes(style.getPropertyValue('clip'));
+        }
+        return style.clipPath === 'none';
+    }
+    function getPendingRevealProperties(container) {
+        if (!container || typeof getComputedStyle !== 'function') {
+            return new Set(revealProperties);
+        }
+        var style = getComputedStyle(container);
+        return new Set(revealProperties.filter(function(property) {
+            return !isRevealed(style, property);
+        }));
+    }
+    function affectsReveal(animation, pendingRevealProperties) {
+        if (pendingRevealProperties.size === 0) {
+            return false;
+        }
+        var effect = animation.effect;
+        if (typeof (effect === null || effect === void 0 ? void 0 : effect.getKeyframes) !== 'function') {
+            return true;
+        }
+        return effect.getKeyframes().some(function(keyframe) {
+            return Array.from(pendingRevealProperties).some(function(property) {
+                return Object.prototype.hasOwnProperty.call(keyframe, property);
+            });
+        });
+    }
+    function startedDuringReveal(current, animationsBeforeReveal) {
+        var previous = animationsBeforeReveal.find(function(param) {
+            var animation = param.animation;
+            return animation === current.animation;
+        });
+        if (!previous) {
+            return true;
+        }
+        if (previous.playState !== current.playState) {
+            return true;
+        }
+        if (current.startTime !== null && previous.startTime !== current.startTime) {
+            return true;
+        }
+        return typeof previous.currentTime === 'number' && typeof current.currentTime === 'number' && current.currentTime < previous.currentTime;
+    }
+    function holdContainerInertUntilReveal(prompt) {
+        var container = getContainer(prompt);
+        if (!(container === null || container === void 0 ? void 0 : container.classList.contains('ais-Chat-container--open')) || container.hasAttribute('inert')) {
+            return;
+        }
+        container.setAttribute('inert', '');
+        containersHeldInert.add(container);
+    }
+    function restoreContainerInertUntilReveal(prompt) {
+        var container = getContainer(prompt);
+        if (container && containersHeldInert.has(container) && getPendingRevealProperties(container).size > 0) {
+            container.setAttribute('inert', '');
+        }
+    }
+    function requestAnimationFrameOrRun(callback) {
+        if (typeof requestAnimationFrame === 'function') {
+            requestAnimationFrame(callback);
+        } else {
+            callback();
+        }
+    }
+    function focusAfterReveal(prompt, animationsBeforeReveal, shouldFocus) {
+        var shouldRelease = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : shouldFocus;
+        var container = getContainer(prompt);
+        var settle = function settle() {
+            if (!shouldRelease()) {
+                return;
+            }
+            if (container) {
+                revealAnimationsHeldByContainer.delete(container);
+            }
+            if (container && containersHeldInert.has(container) && container.classList.contains('ais-Chat-container--open')) {
+                container.removeAttribute('inert');
+                containersHeldInert.delete(container);
+            }
+            if (prompt && shouldFocus()) {
+                prompt.focus();
+            }
+        };
+        var waitForReveal = function waitForReveal1() {
+            var requestIsCurrent = shouldRelease();
+            var pendingRevealProperties = getPendingRevealProperties(container);
+            var heldRevealAnimations = container ? revealAnimationsHeldByContainer.get(container) : undefined;
+            var activeAnimations = getActiveAnimations(container);
+            var heldRevealIsActive = activeAnimations.some(function(param) {
+                var animation = param.animation;
+                return heldRevealAnimations === null || heldRevealAnimations === void 0 ? void 0 : heldRevealAnimations.has(animation);
+            });
+            var replacesInactiveHeldReveal = heldRevealAnimations !== undefined && !heldRevealIsActive;
+            var revealAnimations = activeAnimations.filter(function(current) {
+                var _current_animation_effect;
+                return (startedDuringReveal(current, animationsBeforeReveal) || (heldRevealAnimations === null || heldRevealAnimations === void 0 ? void 0 : heldRevealAnimations.has(current.animation)) || replacesInactiveHeldReveal) && ((_current_animation_effect = current.animation.effect) === null || _current_animation_effect === void 0 ? void 0 : _current_animation_effect.getTiming().iterations) !== Infinity && affectsReveal(current.animation, pendingRevealProperties);
+            });
+            if (container && revealAnimations.length > 0 && (!heldRevealAnimations || requestIsCurrent || !heldRevealIsActive)) {
+                revealAnimationsHeldByContainer.set(container, new Set(revealAnimations.map(function(param) {
+                    var animation = param.animation;
+                    return animation;
+                })));
+            }
+            if (!requestIsCurrent) {
+                if (container && !container.classList.contains('ais-Chat-container--open')) {
+                    revealAnimationsHeldByContainer.delete(container);
+                    containersHeldInert.delete(container);
+                }
+                return;
+            }
+            if (revealAnimations.length === 0) {
+                settle();
+                return;
+            }
+            Promise.all(revealAnimations.map(function(param) {
+                var animation = param.animation;
+                return animation.finished.catch(function() {});
+            })).then(function() {
+                return requestAnimationFrameOrRun(waitForReveal);
+            });
+        };
+        waitForReveal();
+    }
+
     var useStickToBottom = createStickToBottom({
         useCallback: React.useCallback,
         useEffect: React.useEffect,
@@ -25576,11 +26663,24 @@
         createElement: React.createElement,
         Fragment: React.Fragment,
         useMemo: React.useMemo,
-        useState: React.useState
+        useState: React.useState,
+        useEffect: React.useEffect
     });
     function createDefaultTools(itemComponent, getSearchPageURL) {
         var _obj;
-        return _obj = {}, _define_property(_obj, SearchIndexToolType, createCarouselTool(true, itemComponent, getSearchPageURL)), _define_property(_obj, RecommendToolType, createCarouselTool(false, itemComponent, getSearchPageURL)), _define_property(_obj, DisplayResultsToolType, createDisplayResultsTool(itemComponent)), _define_property(_obj, MemorizeToolType, {}), _define_property(_obj, MemorySearchToolType, {}), _define_property(_obj, PonderToolType, {}), _obj;
+        return _obj = {}, _define_property(_obj, SearchIndexToolType, _object_spread_props(_object_spread({}, createCarouselTool(true, itemComponent, getSearchPageURL)), {
+            // The agent decides per turn whether the richer display-results tool
+            // takes over the rendering of the search results.
+            shouldRender: isDisplayResultsDisabled
+        })), _define_property(_obj, RecommendToolType, createCarouselTool(false, itemComponent, getSearchPageURL)), _define_property(_obj, DisplayResultsToolType, createDisplayResultsTool(itemComponent)), _define_property(_obj, MemorizeToolType, {}), _define_property(_obj, MemorySearchToolType, {}), _define_property(_obj, PonderToolType, {}), _obj;
+    }
+    /**
+     * Whether the search tool renders its own results, i.e. the agent did not hand
+     * the turn to the display-results tool. Set on the message by the backend.
+     */ function isDisplayResultsDisabled(param) {
+        var parentMessage = param.parentMessage;
+        var _parentMessage_metadata;
+        return ((_parentMessage_metadata = parentMessage.metadata) === null || _parentMessage_metadata === void 0 ? void 0 : _parentMessage_metadata.displayResultsEnabled) !== true;
     }
     function mergeToolOptions(defaultTools, userTools) {
         if (!userTools) {
@@ -25588,22 +26688,62 @@
         }
         var tools = _object_spread({}, defaultTools, userTools);
         Object.keys(userTools).forEach(function(toolName) {
-            var _defaultTools_toolName;
             var userTool = userTools[toolName];
-            var defaultStreamInput = (_defaultTools_toolName = defaultTools[toolName]) === null || _defaultTools_toolName === void 0 ? void 0 : _defaultTools_toolName.streamInput;
+            var defaultTool = defaultTools[toolName];
+            var defaultStreamInput = defaultTool === null || defaultTool === void 0 ? void 0 : defaultTool.streamInput;
             if (userTool.layoutComponent !== undefined && userTool.streamInput === undefined && defaultStreamInput !== undefined) {
-                tools[toolName] = _object_spread_props(_object_spread({}, userTool), {
+                tools[toolName] = _object_spread_props(_object_spread({}, tools[toolName]), {
                     streamInput: defaultStreamInput
                 });
             }
+            // Overriding a tool's rendering shouldn't opt it out of the conditions
+            // under which the default renders at all.
+            if (userTool.shouldRender === undefined && (defaultTool === null || defaultTool === void 0 ? void 0 : defaultTool.shouldRender)) {
+                tools[toolName] = _object_spread_props(_object_spread({}, tools[toolName]), {
+                    shouldRender: defaultTool.shouldRender
+                });
+            }
         });
         return tools;
     }
+    var AnimationSnapshot = /*#__PURE__*/ function(_React_Component) {
+        _inherits(AnimationSnapshot, _React_Component);
+        function AnimationSnapshot() {
+            _class_call_check(this, AnimationSnapshot);
+            return _call_super(this, AnimationSnapshot, arguments);
+        }
+        _create_class(AnimationSnapshot, [
+            {
+                key: "getSnapshotBeforeUpdate",
+                value: function getSnapshotBeforeUpdate() {
+                    return getActiveContainerAnimations(this.props.promptRef.current);
+                }
+            },
+            {
+                key: "componentDidUpdate",
+                value: function componentDidUpdate(_previousProps, _previousState, animationsBeforeReveal) {
+                    this.props.animationsBeforeReveal.current = animationsBeforeReveal;
+                    if (!_previousProps.open && this.props.open) {
+                        holdContainerInertUntilReveal(this.props.promptRef.current);
+                    } else if (this.props.open) {
+                        restoreContainerInertUntilReveal(this.props.promptRef.current);
+                    }
+                }
+            },
+            {
+                key: "render",
+                value: function render() {
+                    return null;
+                }
+            }
+        ]);
+        return AnimationSnapshot;
+    }(React.Component);
     function ChatInner(_0, _1) {
         var _ref = [
             _0,
             _1
-        ], _ref1 = _to_array(_ref), _ref2 = _ref1[0], _rest = _ref1.slice(1), userTools = _ref2.tools, headerProps = _ref2.headerProps, messagesProps = _ref2.messagesProps, promptProps = _ref2.promptProps, itemComponent = _ref2.itemComponent, layoutComponent = _ref2.layoutComponent, headerComponent = _ref2.headerComponent, headerTitleIconComponent = _ref2.headerTitleIconComponent, headerCloseIconComponent = _ref2.headerCloseIconComponent, headerMinimizeIconComponent = _ref2.headerMinimizeIconComponent, headerMaximizeIconComponent = _ref2.headerMaximizeIconComponent, loaderComponent = _ref2.loaderComponent, messagesErrorComponent = _ref2.messagesErrorComponent, promptComponent = _ref2.promptComponent, promptHeaderComponent = _ref2.promptHeaderComponent, promptFooterComponent = _ref2.promptFooterComponent, assistantMessageLeadingComponent = _ref2.assistantMessageLeadingComponent, assistantMessageFooterComponent = _ref2.assistantMessageFooterComponent, userMessageLeadingComponent = _ref2.userMessageLeadingComponent, userMessageFooterComponent = _ref2.userMessageFooterComponent, emptyComponent = _ref2.emptyComponent, actionsComponent = _ref2.actionsComponent, suggestionsComponent = _ref2.suggestionsComponent, classNames = _ref2.classNames, _ref_translations = _ref2.translations, translations = _ref_translations === void 0 ? {} : _ref_translations, title = _ref2.title, getSearchPageURL = _ref2.getSearchPageURL, _ref_disableTriggerValidation = _ref2.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, showReasoning = _ref2.showReasoning, props = _object_without_properties(_ref2, [
+        ], _ref1 = _to_array(_ref), _ref2 = _ref1[0], _rest = _ref1.slice(1), userTools = _ref2.tools, headerProps = _ref2.headerProps, messagesProps = _ref2.messagesProps, promptProps = _ref2.promptProps, itemComponent = _ref2.itemComponent, layoutComponent = _ref2.layoutComponent, headerComponent = _ref2.headerComponent, headerTitleIconComponent = _ref2.headerTitleIconComponent, headerCloseIconComponent = _ref2.headerCloseIconComponent, headerMinimizeIconComponent = _ref2.headerMinimizeIconComponent, headerMaximizeIconComponent = _ref2.headerMaximizeIconComponent, loaderComponent = _ref2.loaderComponent, loaderPosition = _ref2.loaderPosition, shouldShowLoader = _ref2.shouldShowLoader, loaderShowDelay = _ref2.loaderShowDelay, loaderMinDuration = _ref2.loaderMinDuration, messagesErrorComponent = _ref2.messagesErrorComponent, promptComponent = _ref2.promptComponent, promptHeaderComponent = _ref2.promptHeaderComponent, promptFooterComponent = _ref2.promptFooterComponent, assistantMessageLeadingComponent = _ref2.assistantMessageLeadingComponent, assistantMessageFooterComponent = _ref2.assistantMessageFooterComponent, userMessageLeadingComponent = _ref2.userMessageLeadingComponent, userMessageFooterComponent = _ref2.userMessageFooterComponent, emptyComponent = _ref2.emptyComponent, actionsComponent = _ref2.actionsComponent, suggestionsComponent = _ref2.suggestionsComponent, classNames = _ref2.classNames, _ref_translations = _ref2.translations, translations = _ref_translations === void 0 ? {} : _ref_translations, title = _ref2.title, getSearchPageURL = _ref2.getSearchPageURL, _ref_disableTriggerValidation = _ref2.disableTriggerValidation, disableTriggerValidation = _ref_disableTriggerValidation === void 0 ? false : _ref_disableTriggerValidation, showReasoning = _ref2.showReasoning, props = _object_without_properties(_ref2, [
             "tools",
             "headerProps",
             "messagesProps",
@@ -25616,6 +26756,10 @@
             "headerMinimizeIconComponent",
             "headerMaximizeIconComponent",
             "loaderComponent",
+            "loaderPosition",
+            "shouldShowLoader",
+            "loaderShowDelay",
+            "loaderMinDuration",
             "messagesErrorComponent",
             "promptComponent",
             "promptHeaderComponent",
@@ -25639,6 +26783,8 @@
         var _useInstantSearch = useInstantSearch(), indexUiState = _useInstantSearch.indexUiState, setIndexUiState = _useInstantSearch.setIndexUiState;
         var _useState = _sliced_to_array(React.useState(false), 2), maximized = _useState[0], setMaximized = _useState[1];
         var promptRef = React.useRef(null);
+        var focusRequestId = React.useRef(0);
+        var animationsBeforeReveal = React.useRef([]);
         var _useStickToBottom = useStickToBottom({
             initial: 'smooth',
             resize: 'smooth'
@@ -25660,7 +26806,7 @@
             tools: tools,
             disableTriggerValidation: effectiveDisableTriggerValidation
         }));
-        var messages = chatState.messages, sendMessage = chatState.sendMessage, status = chatState.status, regenerate = chatState.regenerate, stop = chatState.stop, error = chatState.error, input = chatState.input, setInput = chatState.setInput, open = chatState.open, setOpen = chatState.setOpen, clearMessages = chatState.clearMessages, toolsFromConnector = chatState.tools, suggestions = chatState.suggestions, onFeedback = chatState.sendChatMessageFeedback, feedbackState = chatState.feedbackState, consumeInputFocus = chatState['~consumeInputFocus'], isOpenStatePersistenceEnabled = chatState['~isOpenStatePersistenceEnabled'];
+        var messages = chatState.messages, sendMessage = chatState.sendMessage, status = chatState.status, regenerate = chatState.regenerate, stop = chatState.stop, error = chatState.error, input = chatState.input, setInput = chatState.setInput, open = chatState.open, setOpen = chatState.setOpen, clearMessages = chatState.clearMessages, toolsFromConnector = chatState.tools, suggestions = chatState.suggestions, suggestionsStatus = chatState.suggestionsStatus, onFeedback = chatState.sendChatMessageFeedback, feedbackState = chatState.feedbackState, consumeInputFocus = chatState['~consumeInputFocus'], isOpenStatePersistenceEnabled = chatState['~isOpenStatePersistenceEnabled'];
         React.useImperativeHandle(ref, function() {
             return {
                 setOpen: setOpen,
@@ -25671,10 +26817,21 @@
             };
         });
         React.useEffect(function() {
+            if (!open) {
+                focusRequestId.current++;
+                return;
+            }
             if (consumeInputFocus === null || consumeInputFocus === void 0 ? void 0 : consumeInputFocus()) {
+                var currentFocusRequestId = ++focusRequestId.current;
+                var previousAnimations = animationsBeforeReveal.current;
+                holdContainerInertUntilReveal(promptRef.current);
                 window.requestAnimationFrame(function() {
-                    var _promptRef_current;
-                    (_promptRef_current = promptRef.current) === null || _promptRef_current === void 0 ? void 0 : _promptRef_current.focus();
+                    var prompt = promptRef.current;
+                    focusAfterReveal(prompt, previousAnimations, function() {
+                        return focusRequestId.current === currentFocusRequestId && promptRef.current === prompt;
+                    }, function() {
+                        return focusRequestId.current === currentFocusRequestId;
+                    });
                 });
             }
         });
@@ -25702,7 +26859,7 @@
             "assistantMessageProps",
             "userMessageProps"
         ]);
-        return /*#__PURE__*/ React.createElement(ChatUiComponent, {
+        var chat = /*#__PURE__*/ React.createElement(ChatUiComponent, {
             title: title,
             open: open,
             maximized: maximized,
@@ -25754,6 +26911,10 @@
                 contentRef: contentRef,
                 onScrollToBottom: scrollToBottom,
                 loaderComponent: loaderComponent,
+                loaderPosition: loaderPosition,
+                shouldShowLoader: shouldShowLoader,
+                loaderShowDelay: loaderShowDelay,
+                loaderMinDuration: loaderMinDuration,
                 errorComponent: messagesErrorComponent,
                 emptyComponent: emptyComponent,
                 actionsComponent: actionsComponent,
@@ -25795,6 +26956,7 @@
             }),
             suggestionsProps: {
                 suggestions: suggestions,
+                isLoading: suggestionsStatus === 'loading',
                 onSuggestionClick: function onSuggestionClick(suggestion) {
                     sendMessage({
                         text: suggestion
@@ -25803,6 +26965,11 @@
             },
             classNames: classNames
         });
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(AnimationSnapshot, {
+            promptRef: promptRef,
+            animationsBeforeReveal: animationsBeforeReveal,
+            open: open
+        }), chat);
     }
     var Chat = /*#__PURE__*/ React.forwardRef(ChatInner);
 
@@ -25823,16 +26990,20 @@
             "context",
             "transformItems"
         ]);
-        var _usePromptSuggestions = usePromptSuggestions({
+        var source = agentId !== undefined ? {
             agentId: agentId,
-            transport: transport,
+            transport: transport
+        } : {
+            transport: transport
+        };
+        var _usePromptSuggestions = usePromptSuggestions(_object_spread_props(_object_spread({}, source), {
             configurationId: configurationId,
             transformHits: transformHits,
             context: context,
             transformItems: transformItems
-        }, {
+        }), {
             $$widgetType: 'ais.promptSuggestions'
-        }), suggestions = _usePromptSuggestions.suggestions, isLoading = _usePromptSuggestions.isLoading, onSuggestionClick = _usePromptSuggestions.onSuggestionClick, isChatBusy = _usePromptSuggestions.isChatBusy, sendToChat = _usePromptSuggestions.sendToChat;
+        }), suggestions = _usePromptSuggestions.suggestions, isLoading = _usePromptSuggestions.isLoading, error = _usePromptSuggestions.error, onSuggestionClick = _usePromptSuggestions.onSuggestionClick, isChatBusy = _usePromptSuggestions.isChatBusy, sendToChat = _usePromptSuggestions.sendToChat;
         var handleClick = onSuggestionClickOverride ? function(prompt) {
             return onSuggestionClickOverride(prompt, {
                 sendToChat: sendToChat
@@ -25842,6 +27013,7 @@
             return /*#__PURE__*/ React.createElement(LayoutComponent, {
                 suggestions: suggestions,
                 isLoading: isLoading,
+                error: error,
                 onSuggestionClick: handleClick,
                 isChatBusy: isChatBusy
             });