react-instantsearch-core 7.45.0 → 7.47.0

package/dist/umd/ReactInstantSearchCore.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch Core 7.45.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.45.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.112.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) {
@@ -12451,6 +12628,37 @@
     var isPartTool = function isPartTool(part) {
         return startsWith(part.type, 'tool-');
     };
+    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 createRecords = function createRecords() {
         return Object.create(null);
@@ -14410,6 +14618,13 @@
     }
 
     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) {
@@ -14611,7 +14826,7 @@
         name: 'chat',
         connector: true
     });
-    var OPEN_STATE_CACHE_KEY = 'instantsearch-chat-open-state';
+    var OPEN_STATE_CACHE_KEY$1 = 'instantsearch-chat-open-state';
     function normalizePersistence(persistence, hasCustomChat) {
         if (hasCustomChat) {
             return {
@@ -14637,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 {
@@ -14669,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({
@@ -14712,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);
         }
@@ -14722,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",
@@ -14735,11 +14965,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;
@@ -14767,21 +14998,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') {
@@ -14924,14 +15178,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({
@@ -14948,7 +15202,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, '".'),
@@ -14998,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);
@@ -15051,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() {
@@ -15088,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) {
@@ -15178,6 +15436,7 @@
                         '~isOpenStatePersistenceEnabled': normalizedPersistence.open,
                         setMessages: setMessages,
                         suggestions: getSuggestionsFromMessages(_chatInstance.messages),
+                        suggestionsStatus: getSuggestionsStatus(_chatInstance.messages),
                         clearMessages: clearMessages,
                         tools: toolsWithAddToolResult,
                         records: records,
@@ -15253,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;
         }
@@ -15281,120 +15579,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 unwrap(envelope) {
+        if ((typeof envelope === "undefined" ? "undefined" : _type_of(envelope)) === 'object' && envelope !== null && 'output' in envelope) {
+            return envelope.output;
+        }
+        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;
+            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
+                });
             }
         };
     }
@@ -15407,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;
@@ -15464,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();
             };
@@ -15481,32 +15994,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
                         });
                     }
@@ -15538,6 +16050,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;
@@ -15609,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;
@@ -15747,6 +16258,7 @@
                 return {
                     suggestions: transformed,
                     isLoading: isLoading,
+                    error: error,
                     onSuggestionClick: send,
                     sendToChat: send,
                     refresh: refresh,
@@ -15759,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
@@ -15773,14 +16285,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) {
@@ -15803,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) {