react-instantsearch-core 7.46.0 → 7.47.0

package/dist/umd/ReactInstantSearchCore.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch Core 7.46.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch Core 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.46.0';
+    var version$2 = '7.47.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -6728,23 +6728,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() {
@@ -7642,22 +7652,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() {
@@ -8014,6 +8020,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;
@@ -8215,13 +8226,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;
@@ -8231,6 +8239,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
             },
@@ -8592,6 +8667,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);
@@ -8731,6 +8811,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)) {
@@ -8982,7 +9148,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.
@@ -9249,7 +9418,7 @@
         });
     }
 
-    var version = '4.113.0';
+    var version = '4.114.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -11161,6 +11330,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) {
@@ -12456,25 +12633,31 @@
      * Resolves the tool a message part belongs to, from either a part type
      * (`tool-algolia_search_index`) or a bare tool name.
      *
-     * Generic over the tool shape so the renderer, the loader and the connector —
-     * which hold different subsets of the tool contract — all resolve names the same
-     * way.
+     * 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];
         }
-        // Compatibility shim for tool names suffixed by the index name, as the Algolia
-        // MCP Server does (`algolia_search_index_products`). The longest matching key
-        // wins, so registering both `foo` and `foo_bar` resolves `foo_bar_products` to
-        // `foo_bar` — otherwise the winner would depend on registration order.
-        var match;
-        Object.keys(tools).forEach(function(key) {
-            if (startsWith(toolName, "".concat(key, "_")) && (match === undefined || key.length > match.length)) {
-                match = key;
-            }
+        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 match === undefined ? undefined : tools[match];
+        return tools[claimants[0]];
     };
 
     var createRecords = function createRecords() {
@@ -12531,11 +12714,75 @@
         return store;
     }
 
-    function flat(arr) {
-        return arr.reduce(function(acc, array) {
-            return acc.concat(array);
-        }, []);
-    }
+    var tryParseJson = function tryParseJson(value) {
+        try {
+            return JSON.parse(value);
+        } catch (unused) {
+            return undefined;
+        }
+    };
+    var repairPartialJson = function repairPartialJson(value) {
+        var repaired = value.trim();
+        if (!repaired) {
+            return repaired;
+        }
+        var inString = false;
+        var isEscaped = false;
+        var stack = [];
+        for(var index = 0; index < repaired.length; index++){
+            var char = repaired[index];
+            if (inString) {
+                if (isEscaped) {
+                    isEscaped = false;
+                } else if (char === '\\') {
+                    isEscaped = true;
+                } else if (char === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+                continue;
+            }
+            if (char === '{' || char === '[') {
+                stack.push(char);
+                continue;
+            }
+            if (char === '}' && stack[stack.length - 1] === '{') {
+                stack.pop();
+                continue;
+            }
+            if (char === ']' && stack[stack.length - 1] === '[') {
+                stack.pop();
+            }
+        }
+        if (inString && !isEscaped) {
+            repaired += '"';
+        }
+        repaired = repaired.replace(RegExp(",\\s*$", "u"), '');
+        if (stack.length > 0) {
+            repaired += stack.reverse().map(function(opening) {
+                return opening === '{' ? '}' : ']';
+            }).join('');
+        }
+        return repaired.replace(RegExp(",\\s*([}\\]])", "gu"), '$1');
+    };
+    var parsePartialJson = function parsePartialJson(accumulatedRawJson, fallbackValue) {
+        var normalized = accumulatedRawJson.trim();
+        if (!normalized) {
+            return fallbackValue;
+        }
+        var directParsed = tryParseJson(normalized);
+        if (directParsed !== undefined) {
+            return directParsed;
+        }
+        var repairedParsed = tryParseJson(repairPartialJson(normalized));
+        if (repairedParsed !== undefined) {
+            return repairedParsed;
+        }
+        return fallbackValue;
+    };
 
     /**
      * Stream parser for parsing SSE (Server-Sent Events) streams.
@@ -12827,301 +13074,41 @@
         return undefined;
     }
 
-    /**
-     * Reads a human-readable message from a failed HTTP response body when the
-     * server returns JSON such as `{ "message": "..." }` (the shared
-     * `ErrorResponse` shape used by every status code), falling back to the HTTP
-     * status line when the body is empty or not parseable.
-     */ function getHttpErrorMessage(response) {
-        var fallback = "HTTP error: ".concat(response.status, " ").concat(response.statusText);
-        return response.text().then(function(text) {
-            var _tryParseErrorMessage;
-            return (_tryParseErrorMessage = tryParseErrorMessage(text)) !== null && _tryParseErrorMessage !== void 0 ? _tryParseErrorMessage : fallback;
-        }).catch(function() {
-            return fallback;
-        });
+    var _computedKey$1;
+    var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
+    var TOOL_CALL_CANCELLED_ERROR_TEXT = 'The tool call was cancelled: the conversation moved on before a result was provided.';
+    function getToolName(part) {
+        if (part.type === 'dynamic-tool') {
+            var _part_toolName;
+            return (_part_toolName = part.toolName) !== null && _part_toolName !== void 0 ? _part_toolName : part.type;
+        }
+        return part.type.slice('tool-'.length);
+    }
+    function warnInvalidGlobalToolResult(toolCallId) {}
+    // A tool call awaiting an output that the client owns. Provider-executed calls
+    // are resolved server-side, so they are left alone.
+    function isPendingToolPart(part) {
+        var candidate = part;
+        return typeof candidate.type === 'string' && typeof candidate.toolCallId === 'string' && (candidate.state === 'input-streaming' || candidate.state === 'input-available') && candidate.providerExecuted !== true;
+    }
+    // Drops the fields that only belong to the state being left behind:
+    // `output-error` forbids `output`, and a committed output is not `preliminary`.
+    function withTerminalToolState(part, terminalState) {
+        // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.output; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.errorText;
+        var retainedPart = _object_without_properties(part, [
+            "preliminary",
+            "rawOutput",
+            "output",
+            "errorText"
+        ]);
+        return _object_spread({}, retainedPart, terminalState);
     }
-    /**
-     * Abstract base class for HTTP-based chat transports.
-     */ var HttpChatTransport = /*#__PURE__*/ function() {
-        function HttpChatTransport(param) {
-            var _param_api = param.api, api = _param_api === void 0 ? '/api/chat' : _param_api, credentials = param.credentials, headers = param.headers, body = param.body, customFetch = param.fetch, prepareSendMessagesRequest = param.prepareSendMessagesRequest, prepareReconnectToStreamRequest = param.prepareReconnectToStreamRequest;
-            _class_call_check(this, HttpChatTransport);
-            _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);
-            _define_property(this, "prepareReconnectToStreamRequest", void 0);
-            this.api = api;
-            this.credentials = credentials;
-            this.headers = headers;
-            this.body = body;
-            this.fetch = customFetch;
-            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
-            this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
-        }
-        _create_class(HttpChatTransport, [
-            {
-                key: "sendMessages",
-                value: function sendMessages(param) {
-                    var _this = this;
-                    var abortSignal = param.abortSignal, chatId = param.chatId, messages = param.messages, requestMetadata = param.requestMetadata, trigger = param.trigger, messageId = param.messageId, requestHeaders = param.headers, requestBody = param.body;
-                    var _this_fetch;
-                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
-                    // Resolve configurable values
-                    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];
-                        // Build default request options
-                        var api = _this.api;
-                        var body = _object_spread({
-                            id: chatId,
-                            messages: messages
-                        }, resolvedBody, requestBody);
-                        var headers = _object_spread({
-                            'Content-Type': 'application/json'
-                        }, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
-                        var credentials = resolvedCredentials;
-                        // Apply custom preparation if provided
-                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
-                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest({
-                            id: chatId,
-                            messages: messages,
-                            requestMetadata: requestMetadata,
-                            body: prepareRequestBody,
-                            credentials: resolvedCredentials,
-                            headers: resolvedHeaders,
-                            api: _this.api,
-                            trigger: trigger,
-                            messageId: messageId
-                        })) : Promise.resolve(null);
-                        return preparePromise.then(function(prepared) {
-                            if (prepared) {
-                                body = prepared.body;
-                                if (prepared.api) api = prepared.api;
-                                if (prepared.headers) {
-                                    headers = _object_spread({
-                                        'Content-Type': 'application/json'
-                                    }, _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers);
-                                }
-                                if (prepared.credentials) credentials = prepared.credentials;
-                            }
-                            return fetchFn(api, {
-                                method: 'POST',
-                                headers: headers,
-                                body: JSON.stringify(body),
-                                signal: abortSignal,
-                                credentials: credentials
-                            }).then(function(response) {
-                                if (!response.ok) {
-                                    return getHttpErrorMessage(response).then(function(message) {
-                                        throw new Error(message);
-                                    });
-                                }
-                                if (!response.body) {
-                                    throw new Error('Response body is empty');
-                                }
-                                return _this.processResponseStream(response.body);
-                            });
-                        });
-                    });
-                }
-            },
-            {
-                key: "reconnectToStream",
-                value: function reconnectToStream(param) {
-                    var _this = this;
-                    var chatId = param.chatId, requestHeaders = param.headers, requestBody = param.body;
-                    var _this_fetch;
-                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
-                    // Resolve configurable values
-                    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];
-                        // Build default request options
-                        var api = _this.api;
-                        var headers = _object_spread({}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
-                        var credentials = resolvedCredentials;
-                        // Apply custom preparation if provided
-                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
-                        var preparePromise = _this.prepareReconnectToStreamRequest ? Promise.resolve(_this.prepareReconnectToStreamRequest({
-                            id: chatId,
-                            requestMetadata: undefined,
-                            body: prepareRequestBody,
-                            credentials: resolvedCredentials,
-                            headers: resolvedHeaders,
-                            api: _this.api
-                        })) : Promise.resolve(null);
-                        return preparePromise.then(function(prepared) {
-                            if (prepared) {
-                                if (prepared.api) api = prepared.api;
-                                if (prepared.headers) {
-                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
-                                }
-                                if (prepared.credentials) credentials = prepared.credentials;
-                            }
-                            // GET request for reconnection
-                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
-                                method: 'GET',
-                                headers: headers,
-                                credentials: credentials
-                            }).then(function(response) {
-                                if (!response.ok) {
-                                    // 404 means no stream to reconnect to, which is not an error
-                                    if (response.status === 404) {
-                                        return null;
-                                    }
-                                    return getHttpErrorMessage(response).then(function(message) {
-                                        throw new Error(message);
-                                    });
-                                }
-                                if (!response.body) {
-                                    return null;
-                                }
-                                return _this.processResponseStream(response.body);
-                            });
-                        });
-                    });
-                }
-            }
-        ]);
-        return HttpChatTransport;
-    }();
-    /**
-     * Default chat transport implementation using NDJSON streaming.
-     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
-        _inherits(DefaultChatTransport, HttpChatTransport);
-        function DefaultChatTransport() {
-            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-            _class_call_check(this, DefaultChatTransport);
-            return _call_super(this, DefaultChatTransport, [
-                options
-            ]);
-        }
-        _create_class(DefaultChatTransport, [
-            {
-                key: "processResponseStream",
-                value: function processResponseStream(stream) {
-                    return parseJsonEventStream(stream);
-                }
-            }
-        ]);
-        return DefaultChatTransport;
-    }(HttpChatTransport);
-
-    var tryParseJson = function tryParseJson(value) {
-        try {
-            return JSON.parse(value);
-        } catch (unused) {
-            return undefined;
-        }
-    };
-    var repairPartialJson = function repairPartialJson(value) {
-        var repaired = value.trim();
-        if (!repaired) {
-            return repaired;
-        }
-        var inString = false;
-        var isEscaped = false;
-        var stack = [];
-        for(var index = 0; index < repaired.length; index++){
-            var char = repaired[index];
-            if (inString) {
-                if (isEscaped) {
-                    isEscaped = false;
-                } else if (char === '\\') {
-                    isEscaped = true;
-                } else if (char === '"') {
-                    inString = false;
-                }
-                continue;
-            }
-            if (char === '"') {
-                inString = true;
-                continue;
-            }
-            if (char === '{' || char === '[') {
-                stack.push(char);
-                continue;
-            }
-            if (char === '}' && stack[stack.length - 1] === '{') {
-                stack.pop();
-                continue;
-            }
-            if (char === ']' && stack[stack.length - 1] === '[') {
-                stack.pop();
-            }
-        }
-        if (inString && !isEscaped) {
-            repaired += '"';
-        }
-        repaired = repaired.replace(RegExp(",\\s*$", "u"), '');
-        if (stack.length > 0) {
-            repaired += stack.reverse().map(function(opening) {
-                return opening === '{' ? '}' : ']';
-            }).join('');
-        }
-        return repaired.replace(RegExp(",\\s*([}\\]])", "gu"), '$1');
-    };
-    var parsePartialJson = function parsePartialJson(accumulatedRawJson, fallbackValue) {
-        var normalized = accumulatedRawJson.trim();
-        if (!normalized) {
-            return fallbackValue;
-        }
-        var directParsed = tryParseJson(normalized);
-        if (directParsed !== undefined) {
-            return directParsed;
-        }
-        var repairedParsed = tryParseJson(repairPartialJson(normalized));
-        if (repairedParsed !== undefined) {
-            return repairedParsed;
-        }
-        return fallbackValue;
-    };
-
-    var _computedKey$1;
-    var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
-    var TOOL_CALL_CANCELLED_ERROR_TEXT = 'The tool call was cancelled: the conversation moved on before a result was provided.';
-    function getToolName(part) {
-        if (part.type === 'dynamic-tool') {
-            var _part_toolName;
-            return (_part_toolName = part.toolName) !== null && _part_toolName !== void 0 ? _part_toolName : part.type;
-        }
-        return part.type.slice('tool-'.length);
-    }
-    function warnInvalidGlobalToolResult(toolCallId) {}
-    // A tool call awaiting an output that the client owns. Provider-executed calls
-    // are resolved server-side, so they are left alone.
-    function isPendingToolPart(part) {
-        var candidate = part;
-        return typeof candidate.type === 'string' && typeof candidate.toolCallId === 'string' && (candidate.state === 'input-streaming' || candidate.state === 'input-available') && candidate.providerExecuted !== true;
-    }
-    // Drops the fields that only belong to the state being left behind:
-    // `output-error` forbids `output`, and a committed output is not `preliminary`.
-    function withTerminalToolState(part, terminalState) {
-        // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-        part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-        part.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-        part.output; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-        part.errorText;
-        var retainedPart = _object_without_properties(part, [
-            "preliminary",
-            "rawOutput",
-            "output",
-            "errorText"
-        ]);
-        return _object_spread({}, retainedPart, terminalState);
-    }
-    _computedKey$1 = /** @internal */ '~addToolResultForMessage';
-    var _computedKey1$1 = _computedKey$1;
+    _computedKey$1 = /** @internal */ '~addToolResultForMessage';
+    var _computedKey1$1 = _computedKey$1;
     /**
      * Abstract base class for chat implementations.
      */ var AbstractChat = /*#__PURE__*/ function() {
@@ -14587,29 +14574,277 @@
         return Chat;
     }(AbstractChat);
 
-    var withUsage$q = createDocumentationMessageGenerator({
-        name: 'chat',
-        connector: true
-    });
-    var OPEN_STATE_CACHE_KEY = 'instantsearch-chat-open-state';
-    function normalizePersistence(persistence, hasCustomChat) {
-        if (hasCustomChat) {
-            return {
-                messages: false,
-                open: persistence === undefined || (typeof persistence === "undefined" ? "undefined" : _type_of(persistence)) === 'object' && persistence.open === true
-            };
-        }
-        if (persistence === undefined || persistence === true) {
-            return {
-                messages: true,
-                open: true
-            };
+    // Centralizes the "open the chat from an entry point" behavior shared by the
+    // SearchBox AI button, the Autocomplete AI button, prompt suggestions, and any
+    // future entry point. The chat is always opened; the message is only sent when
+    // it is non-empty and the chat is not already processing a message.
+    // Returns true when a message was submitted, so callers can clear their input.
+    function openChat(chatRenderState) {
+        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, message = _ref.message, referer = _ref.referer, turnContext = _ref.turnContext;
+        var _ref1;
+        var _chatRenderState_setOpen;
+        if (!chatRenderState) {
+            return false;
         }
-        if (persistence === false) {
-            return {
-                messages: false,
-                open: false
-            };
+        var trimmed = (_ref1 = message === null || message === void 0 ? void 0 : message.trim()) !== null && _ref1 !== void 0 ? _ref1 : '';
+        if (!trimmed) {
+            if (chatRenderState.focusInput) {
+                chatRenderState.focusInput();
+            } else {
+                var _chatRenderState_setOpen1;
+                (_chatRenderState_setOpen1 = chatRenderState.setOpen) === null || _chatRenderState_setOpen1 === void 0 ? void 0 : _chatRenderState_setOpen1.call(chatRenderState, true);
+            }
+            return false;
+        }
+        (_chatRenderState_setOpen = chatRenderState.setOpen) === null || _chatRenderState_setOpen === void 0 ? void 0 : _chatRenderState_setOpen.call(chatRenderState, true);
+        if (isChatBusy(chatRenderState) || !chatRenderState.sendMessage) {
+            return false;
+        }
+        chatRenderState.sendMessage(_object_spread({
+            text: trimmed
+        }, turnContext ? {
+            metadata: {
+                turnContext: turnContext
+            }
+        } : {}), referer ? {
+            headers: {
+                'x-algolia-referer': referer
+            }
+        } : undefined);
+        return true;
+    }
+    function isChatBusy(chatRenderState) {
+        return (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'submitted' || (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'streaming';
+    }
+
+    var SearchIndexToolType = 'algolia_search_index';
+    /**
+     * 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) {
+            return acc.concat(array);
+        }, []);
+    }
+
+    /**
+     * Reads a human-readable message from a failed HTTP response body when the
+     * server returns JSON such as `{ "message": "..." }` (the shared
+     * `ErrorResponse` shape used by every status code), falling back to the HTTP
+     * status line when the body is empty or not parseable.
+     */ function getHttpErrorMessage(response) {
+        var fallback = "HTTP error: ".concat(response.status, " ").concat(response.statusText);
+        return response.text().then(function(text) {
+            var _tryParseErrorMessage;
+            return (_tryParseErrorMessage = tryParseErrorMessage(text)) !== null && _tryParseErrorMessage !== void 0 ? _tryParseErrorMessage : fallback;
+        }).catch(function() {
+            return fallback;
+        });
+    }
+    /**
+     * Abstract base class for HTTP-based chat transports.
+     */ var HttpChatTransport = /*#__PURE__*/ function() {
+        function HttpChatTransport(param) {
+            var _param_api = param.api, api = _param_api === void 0 ? '/api/chat' : _param_api, credentials = param.credentials, headers = param.headers, body = param.body, customFetch = param.fetch, prepareSendMessagesRequest = param.prepareSendMessagesRequest, prepareReconnectToStreamRequest = param.prepareReconnectToStreamRequest;
+            _class_call_check(this, HttpChatTransport);
+            _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);
+            _define_property(this, "prepareReconnectToStreamRequest", void 0);
+            this.api = api;
+            this.credentials = credentials;
+            this.headers = headers;
+            this.body = body;
+            this.fetch = customFetch;
+            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+            this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
+        }
+        _create_class(HttpChatTransport, [
+            {
+                key: "sendMessages",
+                value: function sendMessages(param) {
+                    var _this = this;
+                    var abortSignal = param.abortSignal, chatId = param.chatId, messages = param.messages, requestMetadata = param.requestMetadata, trigger = param.trigger, messageId = param.messageId, requestHeaders = param.headers, requestBody = param.body;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    // Resolve configurable values
+                    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];
+                        // Build default request options
+                        var api = _this.api;
+                        var body = _object_spread({
+                            id: chatId,
+                            messages: messages
+                        }, resolvedBody, requestBody);
+                        var headers = _object_spread({
+                            'Content-Type': 'application/json'
+                        }, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
+                        var credentials = resolvedCredentials;
+                        // Apply custom preparation if provided
+                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
+                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest({
+                            id: chatId,
+                            messages: messages,
+                            requestMetadata: requestMetadata,
+                            body: prepareRequestBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api,
+                            trigger: trigger,
+                            messageId: messageId
+                        })) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                body = prepared.body;
+                                if (prepared.api) api = prepared.api;
+                                if (prepared.headers) {
+                                    headers = _object_spread({
+                                        'Content-Type': 'application/json'
+                                    }, _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers);
+                                }
+                                if (prepared.credentials) credentials = prepared.credentials;
+                            }
+                            return fetchFn(api, {
+                                method: 'POST',
+                                headers: headers,
+                                body: JSON.stringify(body),
+                                signal: abortSignal,
+                                credentials: credentials
+                            }).then(function(response) {
+                                if (!response.ok) {
+                                    return getHttpErrorMessage(response).then(function(message) {
+                                        throw new Error(message);
+                                    });
+                                }
+                                if (!response.body) {
+                                    throw new Error('Response body is empty');
+                                }
+                                return _this.processResponseStream(response.body);
+                            });
+                        });
+                    });
+                }
+            },
+            {
+                key: "reconnectToStream",
+                value: function reconnectToStream(param) {
+                    var _this = this;
+                    var chatId = param.chatId, requestHeaders = param.headers, requestBody = param.body;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    // Resolve configurable values
+                    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];
+                        // Build default request options
+                        var api = _this.api;
+                        var headers = _object_spread({}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
+                        var credentials = resolvedCredentials;
+                        // Apply custom preparation if provided
+                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
+                        var preparePromise = _this.prepareReconnectToStreamRequest ? Promise.resolve(_this.prepareReconnectToStreamRequest({
+                            id: chatId,
+                            requestMetadata: undefined,
+                            body: prepareRequestBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api
+                        })) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                if (prepared.api) api = prepared.api;
+                                if (prepared.headers) {
+                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
+                                }
+                                if (prepared.credentials) credentials = prepared.credentials;
+                            }
+                            // GET request for reconnection
+                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
+                                method: 'GET',
+                                headers: headers,
+                                credentials: credentials
+                            }).then(function(response) {
+                                if (!response.ok) {
+                                    // 404 means no stream to reconnect to, which is not an error
+                                    if (response.status === 404) {
+                                        return null;
+                                    }
+                                    return getHttpErrorMessage(response).then(function(message) {
+                                        throw new Error(message);
+                                    });
+                                }
+                                if (!response.body) {
+                                    return null;
+                                }
+                                return _this.processResponseStream(response.body);
+                            });
+                        });
+                    });
+                }
+            }
+        ]);
+        return HttpChatTransport;
+    }();
+    /**
+     * Default chat transport implementation using NDJSON streaming.
+     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
+        _inherits(DefaultChatTransport, HttpChatTransport);
+        function DefaultChatTransport() {
+            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            _class_call_check(this, DefaultChatTransport);
+            return _call_super(this, DefaultChatTransport, [
+                options
+            ]);
+        }
+        _create_class(DefaultChatTransport, [
+            {
+                key: "processResponseStream",
+                value: function processResponseStream(stream) {
+                    return parseJsonEventStream(stream);
+                }
+            }
+        ]);
+        return DefaultChatTransport;
+    }(HttpChatTransport);
+
+    var withUsage$q = createDocumentationMessageGenerator({
+        name: 'chat',
+        connector: true
+    });
+    var OPEN_STATE_CACHE_KEY$1 = 'instantsearch-chat-open-state';
+    function normalizePersistence(persistence, hasCustomChat) {
+        if (hasCustomChat) {
+            return {
+                messages: false,
+                open: persistence === undefined || (typeof persistence === "undefined" ? "undefined" : _type_of(persistence)) === 'object' && persistence.open === true
+            };
+        }
+        if (persistence === undefined || persistence === true) {
+            return {
+                messages: true,
+                open: true
+            };
+        }
+        if (persistence === false) {
+            return {
+                messages: false,
+                open: false
+            };
         }
         return {
             messages: persistence.messages === true,
@@ -14617,7 +14852,7 @@
         };
     }
     function getOpenStateCacheKey(type) {
-        return "".concat(OPEN_STATE_CACHE_KEY, "-").concat(type);
+        return "".concat(OPEN_STATE_CACHE_KEY$1, "-").concat(type);
     }
     function readPersistedOpen(type) {
         try {
@@ -14649,6 +14884,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({
@@ -14692,6 +14932,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);
         }
@@ -14702,7 +14952,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",
@@ -14715,6 +14965,12 @@
                 "requiresSearch"
             ]);
             var normalizedPersistence = normalizePersistence(persistence, 'chat' in options);
+            // 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;
@@ -14996,7 +15252,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);
@@ -15049,14 +15306,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() {
@@ -15086,8 +15344,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) {
@@ -15252,9 +15512,48 @@
      * @internal
      */ var useIsHydrated = typeof React__namespace.useSyncExternalStore === 'function' ? useNativeIsHydrated : useLegacyIsHydrated;
 
+    var OPEN_STATE_CACHE_KEY = 'instantsearch-chat-open-state';
+    function isOpenStatePersistenceEnabled(props) {
+        return props.persistence === undefined || props.persistence === true || _type_of(props.persistence) === 'object' && props.persistence.open === true;
+    }
+    function isMessagePersistenceEnabled(props) {
+        return props.persistence === undefined || props.persistence === true || _type_of(props.persistence) === 'object' && props.persistence.messages === true;
+    }
+    function getMessagePersistenceKeySuffix(props) {
+        return props.agentId ? "-".concat(props.agentId) : '';
+    }
+    function hasPersistedOpenState(type) {
+        try {
+            return sessionStorage.getItem("".concat(OPEN_STATE_CACHE_KEY, "-").concat(type)) === 'true';
+        } catch (unused) {
+            return false;
+        }
+    }
     function useChat(props, additionalWidgetProperties) {
         var isHydrated = useIsHydrated();
+        var previousPropsRef = React.useRef(props);
+        var previousChatStateRef = React.useRef(null);
+        useIsomorphicLayoutEffect(function() {
+            {
+                var previousProps = previousPropsRef.current;
+                var previousChatState = previousChatStateRef.current;
+                if (previousChatState && !dequal(previousProps, props) && !('chat' in previousProps)) {
+                    var _props_type;
+                    var nextType = (_props_type = props.type) !== null && _props_type !== void 0 ? _props_type : 'chat';
+                    var losesOpenState = previousChatState.open && (!isOpenStatePersistenceEnabled(props) || !hasPersistedOpenState(nextType));
+                    var canRestoreMessages = isMessagePersistenceEnabled(previousProps) && isMessagePersistenceEnabled(props) && getMessagePersistenceKeySuffix(previousProps) === getMessagePersistenceKeySuffix(props);
+                    var losesMessages = previousChatState.messages.length > 0 && !canRestoreMessages;
+                    { warn(!losesOpenState && !losesMessages, 'Changing the props of the React <Chat> widget replaces its internal Chat instance and clears open state or non-persisted messages. Use stable prop references or provide your own Chat instance to preserve the conversation.'); }
+                }
+                previousPropsRef.current = props;
+            }
+        });
         var chatState = useConnector(connectChat, props, additionalWidgetProperties);
+        useIsomorphicLayoutEffect(function() {
+            {
+                previousChatStateRef.current = chatState;
+            }
+        });
         if (isHydrated) {
             return chatState;
         }
@@ -15308,9 +15607,6 @@
     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];
@@ -15345,27 +15641,56 @@
         }
         return undefined;
     }
-    function consumeTaskStream(body, onData) {
+    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;
-                }
-                if (chunk.type === 'error') {
-                    throw new Error(chunk.errorText || 'Task stream error');
-                }
-                if (chunk.type !== 'data-task-output') {
-                    return;
-                }
-                latest = resolveStreamedOutput(chunk.data, latest);
-                if (onData) {
-                    onData(latest);
+            var publish = function publish(output) {
+                if (!isEqual(output, latest)) {
+                    latest = output;
+                    onData === null || onData === void 0 ? void 0 : onData({
+                        output: output
+                    });
                 }
-            }, function() {
-                return resolve(latest);
-            }, reject);
+            };
+            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() {
@@ -15389,9 +15714,10 @@
             {
                 key: "sendTask",
                 value: function sendTask(param) {
-                    var task = param.task, input = param.input, stream = param.stream, onData = param.onData;
+                    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) {
@@ -15404,7 +15730,7 @@
                 /** @internal */ key: "sendTaskRequest",
                 value: function sendTaskRequest(param) {
                     var _this = this;
-                    var task = param.task, input = param.input, stream = param.stream, onData = param.onData;
+                    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([
@@ -15416,13 +15742,17 @@
                         var api = _this.api;
                         var credentials = resolvedCredentials;
                         var headers = withJsonContentType(resolvedHeaders);
-                        var body = _object_spread({
-                            task: task,
+                        var body = _object_spread(_object_spread_props(_object_spread({}, task === undefined ? {} : {
+                            task: task
+                        }, kind === undefined ? {} : {
+                            kind: kind
+                        }), {
                             input: input
-                        }, resolvedBody);
+                        }), 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,
@@ -15457,8 +15787,11 @@
                                     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);
+                                if (stream && contentType.includes('text/plain')) {
+                                    if (!response.body) {
+                                        throw new Error('Response body is empty');
+                                    }
+                                    return consumeTaskTextStream(response.body, onData);
                                 }
                                 return response.json();
                             });
@@ -15541,7 +15874,7 @@
     }
 
     function createTaskRunner(options) {
-        var task = options.task, _options_stream = options.stream, stream = _options_stream === void 0 ? true : _options_stream;
+        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;
@@ -15552,11 +15885,14 @@
                 headers: options.headers,
                 fetch: options.fetch,
                 prepareSendMessagesRequest: prepareRequest ? function(param) {
-                    var requestTask = param.task, input = param.input;
-                    return prepareRequest({
-                        task: requestTask,
+                    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
             });
         }
@@ -15565,6 +15901,7 @@
                 var onData = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}).onData;
                 return transport.sendTask({
                     task: task,
+                    kind: kind,
                     input: input,
                     stream: stream,
                     onData: onData
@@ -15581,12 +15918,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;
@@ -15638,6 +15975,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();
             };
@@ -15670,6 +16009,7 @@
                         runner = createTaskRunner({
                             transport: taskTransport,
                             task: task,
+                            kind: kind,
                             stream: stream
                         });
                     } else {
@@ -15678,6 +16018,7 @@
                                 transport: transport
                             }),
                             task: task,
+                            kind: kind,
                             stream: stream
                         });
                     }
@@ -15703,55 +16044,13 @@
         };
     };
 
-    // Centralizes the "open the chat from an entry point" behavior shared by the
-    // SearchBox AI button, the Autocomplete AI button, prompt suggestions, and any
-    // future entry point. The chat is always opened; the message is only sent when
-    // it is non-empty and the chat is not already processing a message.
-    // Returns true when a message was submitted, so callers can clear their input.
-    function openChat(chatRenderState) {
-        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, message = _ref.message, referer = _ref.referer, turnContext = _ref.turnContext;
-        var _ref1;
-        var _chatRenderState_setOpen;
-        if (!chatRenderState) {
-            return false;
-        }
-        var trimmed = (_ref1 = message === null || message === void 0 ? void 0 : message.trim()) !== null && _ref1 !== void 0 ? _ref1 : '';
-        if (!trimmed) {
-            if (chatRenderState.focusInput) {
-                chatRenderState.focusInput();
-            } else {
-                var _chatRenderState_setOpen1;
-                (_chatRenderState_setOpen1 = chatRenderState.setOpen) === null || _chatRenderState_setOpen1 === void 0 ? void 0 : _chatRenderState_setOpen1.call(chatRenderState, true);
-            }
-            return false;
-        }
-        (_chatRenderState_setOpen = chatRenderState.setOpen) === null || _chatRenderState_setOpen === void 0 ? void 0 : _chatRenderState_setOpen.call(chatRenderState, true);
-        if (isChatBusy(chatRenderState) || !chatRenderState.sendMessage) {
-            return false;
-        }
-        chatRenderState.sendMessage(_object_spread({
-            text: trimmed
-        }, turnContext ? {
-            metadata: {
-                turnContext: turnContext
-            }
-        } : {}), referer ? {
-            headers: {
-                'x-algolia-referer': referer
-            }
-        } : undefined);
-        return true;
-    }
-    function isChatBusy(chatRenderState) {
-        return (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'submitted' || (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'streaming';
-    }
-
     var withUsage$o = createDocumentationMessageGenerator({
         name: 'prompt-suggestions',
         connector: true
     });
     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;
@@ -15823,12 +16122,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;
@@ -15961,6 +16258,7 @@
                 return {
                     suggestions: transformed,
                     isLoading: isLoading,
+                    error: error,
                     onSuggestionClick: send,
                     sendToChat: send,
                     refresh: refresh,
@@ -15973,10 +16271,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
@@ -15993,12 +16291,14 @@
                     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 {
@@ -16027,6 +16327,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) {