react-instantsearch-core 7.47.0 → 7.49.0

package/dist/umd/ReactInstantSearchCore.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch Core 7.47.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch Core 7.49.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.47.0';
+    var version$2 = '7.49.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -9418,7 +9418,7 @@
         });
     }
 
-    var version = '4.114.0';
+    var version = '4.116.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -13077,6 +13077,26 @@
     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.';
+    var RESTORED_TOOL_CALL_ERROR_TEXT = 'The page was reloaded before a tool result was received. The operation may have completed.';
+    var RESTORED_TOOL_INPUT_ERROR_TEXT = 'The page was reloaded before the tool input was complete. The operation was not started.';
+    function getTerminalToolState(options) {
+        if (options.state === 'output-error') {
+            return {
+                state: 'output-error',
+                errorText: options.errorText || 'Tool call failed.'
+            };
+        }
+        if (options.state === undefined && 'errorText' in options && typeof options.errorText === 'string') {
+            return {
+                state: 'output-error',
+                errorText: options.errorText || 'Tool call failed.'
+            };
+        }
+        return {
+            state: 'output-available',
+            output: options.output
+        };
+    }
     function getToolName(part) {
         if (part.type === 'dynamic-tool') {
             var _part_toolName;
@@ -13114,7 +13134,7 @@
      */ var AbstractChat = /*#__PURE__*/ function() {
         function AbstractChat(param) {
             var _this = this;
-            var _param_generateId = param.generateId, generateId$1 = _param_generateId === void 0 ? generateId : _param_generateId, _param_id = param.id, id = _param_id === void 0 ? generateId$1() : _param_id, transport = param.transport, state = param.state, onError = param.onError, onToolCall = param.onToolCall, onFinish = param.onFinish, onData = param.onData, sendAutomaticallyWhen = param.sendAutomaticallyWhen, shouldRepairToolInput = param.shouldRepairToolInput, resolveCancelledToolOutput = param.resolveCancelledToolOutput;
+            var _param_generateId = param.generateId, generateId$1 = _param_generateId === void 0 ? generateId : _param_generateId, _param_id = param.id, id = _param_id === void 0 ? generateId$1() : _param_id, transport = param.transport, state = param.state, onError = param.onError, onToolCall = param.onToolCall, onFinish = param.onFinish, onData = param.onData, sendAutomaticallyWhen = param.sendAutomaticallyWhen, shouldRepairToolInput = param.shouldRepairToolInput, shouldRepairRestoredPendingToolPart = param.shouldRepairRestoredPendingToolPart, resolveCancelledToolOutput = param.resolveCancelledToolOutput;
             var _this1 = this;
             _class_call_check(this, AbstractChat);
             _define_property(this, "conversationId", void 0);
@@ -13127,11 +13147,13 @@
             _define_property(this, "onData", void 0);
             _define_property(this, "sendAutomaticallyWhen", void 0);
             _define_property(this, "shouldRepairToolInput", void 0);
+            _define_property(this, "shouldRepairRestoredPendingToolPart", void 0);
             _define_property(this, "resolveCancelledToolOutput", void 0);
             _define_property(this, "activeResponse", null);
             _define_property(this, "latestResponse", null);
             _define_property(this, "responsesByToolCallId", new Map());
             _define_property(this, "responseByMessage", new WeakMap());
+            _define_property(this, "restoredToolCalls", void 0);
             // Once tool ownership is discarded, an identifier-only result cannot prove
             // which response generation submitted it. Scoped submissions remain safe.
             _define_property(this, "acceptsIdentifierOnlyToolResults", true);
@@ -13299,7 +13321,7 @@
                         warnInvalidGlobalToolResult(options.toolCallId);
                         return Promise.resolve();
                     }
-                    if (!_this.commit(options.toolCallId, options.output, message.id, undefined, message)) {
+                    if (!_this.commit(options.toolCallId, getTerminalToolState(options), message.id, undefined, message)) {
                         return Promise.resolve();
                     }
                     return _this.continueResponse();
@@ -13346,6 +13368,7 @@
             this.onData = onData;
             this.sendAutomaticallyWhen = sendAutomaticallyWhen;
             this.shouldRepairToolInput = shouldRepairToolInput;
+            this.shouldRepairRestoredPendingToolPart = shouldRepairRestoredPendingToolPart;
             this.resolveCancelledToolOutput = resolveCancelledToolOutput;
         }
         _create_class(AbstractChat, [
@@ -13518,7 +13541,7 @@
             },
             {
                 key: "commit",
-                value: function commit(toolCallId, output, messageId, response, expectedMessage) {
+                value: function commit(toolCallId, terminalState, messageId, response, expectedMessage) {
                     var isTargetPart = function isTargetPart(part) {
                         return 'toolCallId' in part && part.toolCallId === toolCallId;
                     };
@@ -13533,10 +13556,7 @@
                         return false;
                     }
                     var updatedParts = _to_consumable_array(message.parts);
-                    updatedParts[partIndex] = withTerminalToolState(part, {
-                        state: 'output-available',
-                        output: output
-                    });
+                    updatedParts[partIndex] = withTerminalToolState(part, terminalState);
                     var updatedMessage = _object_spread_props(_object_spread({}, message), {
                         parts: updatedParts
                     });
@@ -13544,6 +13564,60 @@
                     return true;
                 }
             },
+            {
+                key: "captureRestoredToolCalls",
+                value: function captureRestoredToolCalls() {
+                    var restoredToolCalls = new Map();
+                    this.messages.forEach(function(message) {
+                        message.parts.forEach(function(part) {
+                            var _restoredToolCalls_get;
+                            if (!isPendingToolPart(part)) return;
+                            var toolCallIds = (_restoredToolCalls_get = restoredToolCalls.get(message.id)) !== null && _restoredToolCalls_get !== void 0 ? _restoredToolCalls_get : new Set();
+                            toolCallIds.add(part.toolCallId);
+                            restoredToolCalls.set(message.id, toolCallIds);
+                        });
+                    });
+                    this.restoredToolCalls = restoredToolCalls;
+                }
+            },
+            {
+                key: "clearRestoredToolCalls",
+                value: function clearRestoredToolCalls() {
+                    this.restoredToolCalls = undefined;
+                }
+            },
+            {
+                key: "repairRestoredPendingToolParts",
+                value: function repairRestoredPendingToolParts() {
+                    var _this = this;
+                    var shouldRepairRestoredPendingToolPart = this.shouldRepairRestoredPendingToolPart;
+                    if (!shouldRepairRestoredPendingToolPart) return;
+                    this.messages.forEach(function(message, messageIndex) {
+                        message.parts.forEach(function(part) {
+                            var _this_restoredToolCalls_get;
+                            if (!isPendingToolPart(part)) return;
+                            if (_this.restoredToolCalls && !((_this_restoredToolCalls_get = _this.restoredToolCalls.get(message.id)) === null || _this_restoredToolCalls_get === void 0 ? void 0 : _this_restoredToolCalls_get.has(part.toolCallId))) {
+                                return;
+                            }
+                            var shouldRepair = false;
+                            try {
+                                shouldRepair = shouldRepairRestoredPendingToolPart({
+                                    toolName: getToolName(part),
+                                    toolCallId: part.toolCallId,
+                                    input: 'input' in part ? part.input : undefined
+                                });
+                            } catch (unused) {
+                                return;
+                            }
+                            if (!shouldRepair) return;
+                            _this.commit(part.toolCallId, {
+                                state: 'output-error',
+                                errorText: part.state === 'input-streaming' ? RESTORED_TOOL_INPUT_ERROR_TEXT : RESTORED_TOOL_CALL_ERROR_TEXT
+                            }, message.id, undefined, _this.messages[messageIndex]);
+                        });
+                    });
+                }
+            },
             {
                 key: "getOutboundMessages",
                 value: /**
@@ -13678,18 +13752,18 @@
             },
             {
                 key: "submitToolResult",
-                value: function submitToolResult(response, param) {
+                value: function submitToolResult(response, options) {
                     var _this = this;
-                    var toolCallId = param.toolCallId, output = param.output, messageId = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : response === null || response === void 0 ? void 0 : response.messageId, expectedMessage = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : messageId ? this.messages.find(function(message) {
+                    var messageId = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : response === null || response === void 0 ? void 0 : response.messageId, expectedMessage = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : messageId ? this.messages.find(function(message) {
                         return message.id === messageId;
                     }) : undefined;
                     if (response === null || response === void 0 ? void 0 : response.isRetired) return Promise.resolve();
                     var commitResult = function commitResult() {
-                        if (!_this.commit(toolCallId, output, messageId, response, expectedMessage)) {
+                        if (!_this.commit(options.toolCallId, getTerminalToolState(options), messageId, response, expectedMessage)) {
                             return Promise.resolve();
                         }
-                        if (response === null || response === void 0 ? void 0 : response.requiredToolCallIds.has(toolCallId)) {
-                            response.resolvedToolCallIds.add(toolCallId);
+                        if (response === null || response === void 0 ? void 0 : response.requiredToolCallIds.has(options.toolCallId)) {
+                            response.resolvedToolCallIds.add(options.toolCallId);
                         }
                         return _this.continueResponse(response);
                     };
@@ -14073,13 +14147,16 @@
                                             _this.responsesByToolCallId.set(chunk.toolCallId, owners);
                                             response.pendingToolCallbacks++;
                                             try {
+                                                var _this_restoredToolCalls_get, _this_restoredToolCalls;
+                                                (_this_restoredToolCalls = _this.restoredToolCalls) === null || _this_restoredToolCalls === void 0 ? void 0 : (_this_restoredToolCalls_get = _this_restoredToolCalls.get(currentMessage.id)) === null || _this_restoredToolCalls_get === void 0 ? void 0 : _this_restoredToolCalls_get.delete(chunk.toolCallId);
                                                 var result = _this.onToolCall({
                                                     toolCall: {
                                                         toolName: chunk.toolName,
                                                         toolCallId: chunk.toolCallId,
                                                         input: chunk.input,
                                                         dynamic: 'dynamic' in chunk ? chunk.dynamic : undefined
-                                                    }
+                                                    },
+                                                    signal: response.abortController.signal
                                                 }, function(options) {
                                                     return response.isRetired ? Promise.resolve() : _this.submitToolResult(response, options);
                                                 });
@@ -14399,7 +14476,7 @@
         return AbstractChat;
     }();
 
-    var _computedKey, _computedKey1, _computedKey2, _computedKey3, _computedKey4, _computedKey5;
+    var _computedKey, _computedKey1, _computedKey2, _computedKey3, _computedKey4, _computedKey5, _computedKey6, _computedKey7;
     var CACHE_KEY = 'instantsearch-chat-initial-messages';
     // Message history is a browser concern, and a server render constructs a Chat
     // too. Reading storage there throws during rendering; the write below only
@@ -14421,8 +14498,8 @@
             }
         });
     }
-    _computedKey = '~registerMessagesCallback', _computedKey1 = '~registerStatusCallback', _computedKey2 = '~registerErrorCallback';
-    var _computedKey6 = _computedKey, _computedKey7 = _computedKey1, _computedKey8 = _computedKey2;
+    _computedKey = '~persistMessages', _computedKey1 = '~registerMessagesCallback', _computedKey2 = '~registerStatusCallback', _computedKey3 = '~registerErrorCallback';
+    var _computedKey8 = _computedKey, _computedKey9 = _computedKey1, _computedKey10 = _computedKey2, _computedKey11 = _computedKey3;
     var ChatState = /*#__PURE__*/ function() {
         function ChatState() {
             var _this = this;
@@ -14434,6 +14511,7 @@
             _define_property(this, "_messagesCallbacks", new Set());
             _define_property(this, "_statusCallbacks", new Set());
             _define_property(this, "_errorCallbacks", new Set());
+            _define_property(this, "persistenceKey", void 0);
             _define_property(this, "pushMessage", function(message) {
                 _this._messages = _this._messages.concat(message);
                 _this._callMessagesCallbacks();
@@ -14452,20 +14530,31 @@
             _define_property(this, "snapshot", function(thing) {
                 return JSON.parse(JSON.stringify(thing));
             });
-            _define_property(this, _computedKey6, function(onChange) {
+            _define_property(this, _computedKey8, function() {
+                var persistenceKey = _this.persistenceKey;
+                if (!persistenceKey) return;
+                safelyRunOnBrowser(function() {
+                    try {
+                        sessionStorage.setItem(persistenceKey, JSON.stringify(_this.messages));
+                    } catch (e) {
+                    // Do nothing if sessionStorage is not available or full
+                    }
+                });
+            });
+            _define_property(this, _computedKey9, function(onChange) {
                 var callback = onChange;
                 _this._messagesCallbacks.add(callback);
                 return function() {
                     _this._messagesCallbacks.delete(callback);
                 };
             });
-            _define_property(this, _computedKey7, function(onChange) {
+            _define_property(this, _computedKey10, function(onChange) {
                 _this._statusCallbacks.add(onChange);
                 return function() {
                     _this._statusCallbacks.delete(onChange);
                 };
             });
-            _define_property(this, _computedKey8, function(onChange) {
+            _define_property(this, _computedKey11, function(onChange) {
                 _this._errorCallbacks.add(onChange);
                 return function() {
                     _this._errorCallbacks.delete(onChange);
@@ -14496,19 +14585,14 @@
             if (!persistence) {
                 return;
             }
-            var saveMessagesInLocalStorage = function saveMessagesInLocalStorage() {
+            this.persistenceKey = CACHE_KEY + (id ? "-".concat(id) : '');
+            var saveMessagesInSessionStorage = function saveMessagesInSessionStorage() {
                 if (_this.status === 'ready') {
-                    safelyRunOnBrowser(function() {
-                        try {
-                            sessionStorage.setItem(CACHE_KEY + (id ? "-".concat(id) : ''), JSON.stringify(_this.messages));
-                        } catch (e) {
-                        // Do nothing if sessionStorage is not available or full
-                        }
-                    });
+                    _this['~persistMessages']();
                 }
             };
-            this['~registerMessagesCallback'](saveMessagesInLocalStorage);
-            this['~registerStatusCallback'](saveMessagesInLocalStorage);
+            this['~registerMessagesCallback'](saveMessagesInSessionStorage);
+            this['~registerStatusCallback'](saveMessagesInSessionStorage);
         }
         _create_class(ChatState, [
             {
@@ -14544,8 +14628,8 @@
         ]);
         return ChatState;
     }();
-    _computedKey3 = '~registerMessagesCallback', _computedKey4 = '~registerStatusCallback', _computedKey5 = '~registerErrorCallback';
-    var _computedKey9 = _computedKey3, _computedKey10 = _computedKey4, _computedKey11 = _computedKey5;
+    _computedKey4 = '~repairRestoredPendingToolParts', _computedKey5 = '~registerMessagesCallback', _computedKey6 = '~registerStatusCallback', _computedKey7 = '~registerErrorCallback';
+    var _computedKey12 = _computedKey4, _computedKey13 = _computedKey5, _computedKey14 = _computedKey6, _computedKey15 = _computedKey7;
     var Chat = /*#__PURE__*/ function(AbstractChat) {
         _inherits(Chat, AbstractChat);
         function Chat(_0) {
@@ -14561,14 +14645,25 @@
                 _object_spread_props(_object_spread({}, init), {
                     state: state
                 })
-            ]), _define_property(_this, "_state", void 0), _define_property(_this, _computedKey9, function(onChange) {
+            ]), _define_property(_this, "_state", void 0), _define_property(_this, "hasRestoredMessages", false), _define_property(_this, _computedKey12, function() {
+                if (!_this.hasRestoredMessages) return;
+                _this.hasRestoredMessages = false;
+                _this.repairRestoredPendingToolParts();
+                _this.clearRestoredToolCalls();
+                _this._state['~persistMessages']();
+            }), _define_property(_this, _computedKey13, function(onChange) {
                 return _this._state['~registerMessagesCallback'](onChange);
-            }), _define_property(_this, _computedKey10, function(onChange) {
+            }), _define_property(_this, _computedKey14, function(onChange) {
                 return _this._state['~registerStatusCallback'](onChange);
-            }), _define_property(_this, _computedKey11, function(onChange) {
+            }), _define_property(_this, _computedKey15, function(onChange) {
                 return _this._state['~registerErrorCallback'](onChange);
             });
             _this._state = state;
+            if (messages === undefined && persistence) {
+                _this.hasRestoredMessages = true;
+                _this.captureRestoredToolCalls();
+                _this.repairRestoredPendingToolParts();
+            }
             return _this;
         }
         return Chat;
@@ -14826,6 +14921,9 @@
         name: 'chat',
         connector: true
     });
+    var DEFAULT_TOOL_TIMEOUT = 20000;
+    var TOOL_TIMEOUT_ERROR_TEXT = 'The tool call timed out before a result was received. The operation may have completed.';
+    var TOOL_ABORTED_ERROR_TEXT = 'The tool call was cancelled before a result was received.';
     var OPEN_STATE_CACHE_KEY$1 = 'instantsearch-chat-open-state';
     function normalizePersistence(persistence, hasCustomChat) {
         if (hasCustomChat) {
@@ -15173,7 +15271,8 @@
                 if (!transport) {
                     throw new Error(withUsage$q('You need to provide either an `agentId` or a `transport`.'));
                 }
-                return new Chat(_object_spread_props(_object_spread({}, options), {
+                var canRepairRestoredPendingToolParts = !resume;
+                var chat = new Chat(_object_spread_props(_object_spread({}, options), {
                     persistence: normalizedPersistence.messages,
                     sendAutomaticallyWhen: sendAutomaticallyWhen,
                     transport: transport,
@@ -15182,6 +15281,11 @@
                         if (!tool) return true;
                         return Boolean(tool.streamInput);
                     },
+                    shouldRepairRestoredPendingToolPart: function shouldRepairRestoredPendingToolPart(param) {
+                        var toolName = param.toolName;
+                        var tool = findTool(toolName, tools);
+                        return Boolean(canRepairRestoredPendingToolParts && (tool === null || tool === void 0 ? void 0 : tool.onToolCall) && tool.timeout !== false);
+                    },
                     resolveCancelledToolOutput: function resolveCancelledToolOutput(param) {
                         var toolName = param.toolName, toolCallId = param.toolCallId, input = param.input;
                         var _findTool;
@@ -15201,7 +15305,7 @@
                         }
                     },
                     onToolCall: function onToolCall(param, submitToolResult) {
-                        var toolCall = param.toolCall;
+                        var toolCall = param.toolCall, signal = param.signal;
                         var tool = findTool(toolCall.toolName, tools);
                         if (!tool) {
                             return submitToolResult({
@@ -15211,21 +15315,103 @@
                             });
                         }
                         if (tool.onToolCall) {
-                            var addToolResult = function addToolResult(param) {
-                                var output = param.output;
-                                return submitToolResult({
-                                    output: output,
+                            var toolAbortController = new AbortController();
+                            var timeoutId;
+                            var settled = false;
+                            var resolveExecution;
+                            var rejectExecution;
+                            var execution = new Promise(function(resolve, reject) {
+                                resolveExecution = resolve;
+                                rejectExecution = reject;
+                            });
+                            var cleanup = function cleanup() {
+                                if (timeoutId !== undefined) {
+                                    clearTimeout(timeoutId);
+                                }
+                                signal.removeEventListener('abort', abortToolCall);
+                            };
+                            var addToolResult = function addToolResult(options) {
+                                if (settled) return Promise.resolve();
+                                settled = true;
+                                cleanup();
+                                var submission = submitToolResult(_object_spread_props(_object_spread({}, options), {
                                     tool: toolCall.toolName,
                                     toolCallId: toolCall.toolCallId
+                                }));
+                                submission.then(resolveExecution, rejectExecution);
+                                return submission;
+                            };
+                            var addToolError = function addToolError(error) {
+                                var errorText = _instanceof(error, Error) ? error.message : String(error !== null && error !== void 0 ? error : '');
+                                return addToolResult({
+                                    state: 'output-error',
+                                    errorText: errorText || 'Tool call failed.'
                                 });
                             };
-                            return tool.onToolCall(_object_spread_props(_object_spread({}, toolCall), {
-                                addToolResult: addToolResult
-                            }));
+                            function abortToolCall() {
+                                var submission = addToolResult({
+                                    state: 'output-error',
+                                    errorText: TOOL_ABORTED_ERROR_TEXT
+                                });
+                                toolAbortController.abort();
+                                void submission.catch(function() {
+                                    return undefined;
+                                });
+                            }
+                            if (signal.aborted) {
+                                abortToolCall();
+                                return execution;
+                            }
+                            signal.addEventListener('abort', abortToolCall, {
+                                once: true
+                            });
+                            if (tool.timeout !== false) {
+                                var _tool_timeout;
+                                timeoutId = setTimeout(function() {
+                                    var submission = addToolResult({
+                                        state: 'output-error',
+                                        errorText: TOOL_TIMEOUT_ERROR_TEXT
+                                    });
+                                    toolAbortController.abort();
+                                    void submission.catch(function() {
+                                        return undefined;
+                                    });
+                                }, (_tool_timeout = tool.timeout) !== null && _tool_timeout !== void 0 ? _tool_timeout : DEFAULT_TOOL_TIMEOUT);
+                            }
+                            var toolExecution;
+                            try {
+                                toolExecution = tool.onToolCall(_object_spread_props(_object_spread({}, toolCall), {
+                                    addToolResult: addToolResult,
+                                    signal: toolAbortController.signal
+                                }));
+                            } catch (error) {
+                                return addToolError(error);
+                            }
+                            var returnedExecution = Promise.resolve(toolExecution).catch(addToolError);
+                            if (tool.timeout === false) {
+                                return Promise.race([
+                                    returnedExecution.then(cleanup),
+                                    execution
+                                ]);
+                            }
+                            void returnedExecution.catch(function() {
+                                return undefined;
+                            });
+                            return execution;
                         }
                         return Promise.resolve();
                     }
                 }));
+                if (resume) {
+                    var resumeStream = chat.resumeStream;
+                    chat.resumeStream = function(requestOptions) {
+                        return resumeStream(requestOptions).finally(function() {
+                            canRepairRestoredPendingToolParts = true;
+                            chat['~repairRestoredPendingToolParts']();
+                        });
+                    };
+                }
+                return chat;
             };
             return {
                 $$type: 'ais.chat',
@@ -16061,8 +16247,35 @@
             return typeof s === 'string';
         });
     }
-    function buildSuggestionMessage(suggestion) {
-        return "The user clicked this on-page suggestion. Use the current page context first, then search only if needed.\n\nSuggestion: ".concat(suggestion);
+    // Key order is not significant to the request, so a plain `JSON.stringify` would
+    // report two identical payloads as different.
+    function stableKey(value) {
+        if (value === null || (typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object') {
+            var _JSON_stringify;
+            return (_JSON_stringify = JSON.stringify(value)) !== null && _JSON_stringify !== void 0 ? _JSON_stringify : 'null';
+        }
+        if (Array.isArray(value)) {
+            return "[".concat(value.map(stableKey).join(','), "]");
+        }
+        var record = value;
+        return "{".concat(Object.keys(record).sort().map(function(key) {
+            return "".concat(JSON.stringify(key), ":").concat(stableKey(record[key]));
+        }).join(','), "}");
+    }
+    /**
+     * Comparable identity of a task payload, or `null` when it cannot be compared.
+     */ function taskPayloadKey(payload) {
+        try {
+            // Round-trip first so the comparison sees what the request will actually
+            // carry: `JSON.stringify` applies `toJSON` (a `Date` becomes its ISO string)
+            // and drops the values the wire drops. Walking the raw object instead would
+            // read a `Date` as a key-less object and call two different instants equal.
+            return stableKey(JSON.parse(JSON.stringify(payload)));
+        } catch (unused) {
+            // Circular or otherwise unserializable. Never claim a match on a payload we
+            // could not read; let the request go out and fail where it does today.
+            return null;
+        }
     }
     function stripInternalHitMetadata(hit) {
         var clean = {};
@@ -16128,16 +16341,27 @@
             var error;
             var debounceTimer;
             var lastStateSignature = null;
+            // The payload of the last request that was actually sent. The automatic
+            // trigger keys on the search state, which is only a proxy for the payload,
+            // so this is what decides whether a request would ask anything new.
+            var lastSubmittedPayload = null;
             var latestRenderOptions = null;
             // Set in `dispose()`. A debounced or in-flight `fetch()` can resolve after
             // the widget is unmounted; this guard stops those late callbacks from
             // calling `renderFn` into a torn-down container.
             var disposed = false;
+            // Whether the "is a chat widget mounted on this index?" question has been
+            // settled — see `validateChat`.
+            var hasValidatedChat = false;
             // True between a state-signature change and the debounced refetch that
             // follows it. While pending, the search state has already moved on, so a
             // still-in-flight request from the previous state must not paint its
             // suggestions, its inner render is ignored until the new `submit` starts.
             var refetchPending = false;
+            // True when `refetchPending` made an inner render be dropped. The fetch
+            // that dropped it was expected to render in its place; if that fetch turns
+            // out to send nothing, it has to reconcile the dropped state instead.
+            var droppedInnerRender = false;
             var getStateSignature = function getStateSignature(results) {
                 var _buildFilters;
                 if (results.queryID) {
@@ -16161,21 +16385,26 @@
             };
             var sendToChat = function sendToChat(renderOptions) {
                 return function(prompt) {
-                    var _ref, _ref1;
+                    var _ref, _getLatestResults;
                     var chatRenderState = getChatRenderState(renderOptions);
                     if (!chatRenderState || !chatRenderState.sendMessage) {
                         return false;
                     }
-                    var results = (_ref = (_ref1 = latestRenderOptions === null || latestRenderOptions === void 0 ? void 0 : latestRenderOptions.results) !== null && _ref1 !== void 0 ? _ref1 : 'results' in renderOptions ? renderOptions.results : null) !== null && _ref !== void 0 ? _ref : null;
+                    var results = (_ref = (_getLatestResults = getLatestResults()) !== null && _getLatestResults !== void 0 ? _getLatestResults : 'results' in renderOptions ? renderOptions.results : null) !== null && _ref !== void 0 ? _ref : null;
                     return openChat(chatRenderState, {
-                        message: buildSuggestionMessage(prompt),
+                        message: prompt,
                         referer: 'prompt-suggestions-widget',
                         turnContext: buildTurnContext(results)
                     });
                 };
             };
-            var resolvePageContext = function resolvePageContext(results) {
-                var resolvedContext = typeof context === 'function' ? context() : context;
+            // `context` may be a function, so the option alone says nothing about what
+            // a given fetch actually has to send. Resolve it once per fetch and let
+            // callers read the value rather than the option.
+            var resolveContext = function resolveContext() {
+                return typeof context === 'function' ? context() : context;
+            };
+            var buildPageContext = function buildPageContext(resolvedContext, results) {
                 // Explicit context replaces auto-extraction; otherwise derive it from
                 // the current search state. The task's server-owned instructions decide
                 // how to interpret the shape — the client doesn't label it.
@@ -16194,15 +16423,11 @@
                     hitsSample: transformHits(results.hits)
                 });
             };
-            var buildInput = function buildInput(results) {
-                var _resolvePageContext;
-                return (_resolvePageContext = resolvePageContext(results)) !== null && _resolvePageContext !== void 0 ? _resolvePageContext : {};
-            };
             // The same page context, flattened for the chat handoff: `turnContext` is
             // a flat `Record<string, string>` per the Agent Studio contract, so
             // non-string values (e.g. `hitsSample`) are serialized.
             var buildTurnContext = function buildTurnContext(results) {
-                var pageContext = resolvePageContext(results);
+                var pageContext = buildPageContext(resolveContext(), results);
                 if (!pageContext) {
                     return undefined;
                 }
@@ -16218,33 +16443,98 @@
                 });
                 return entries.length > 0 ? Object.fromEntries(entries) : undefined;
             };
+            // `latestRenderOptions` may be the `init()` options, which carry no
+            // `results` key at all, so the read has to be narrowed rather than
+            // optional-chained.
+            var getLatestResults = function getLatestResults() {
+                var _latestRenderOptions_results;
+                if (!latestRenderOptions || !('results' in latestRenderOptions)) {
+                    return null;
+                }
+                return (_latestRenderOptions_results = latestRenderOptions.results) !== null && _latestRenderOptions_results !== void 0 ? _latestRenderOptions_results : null;
+            };
             var renderOutward = function renderOutward(renderOptions) {
                 if (disposed) return;
                 renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(renderOptions)), {
                     instantSearchInstance: renderOptions.instantSearchInstance
                 }), false);
             };
+            // Copies an inner render's state into this widget's and re-renders on the
+            // client.
+            var adoptInnerState = function adoptInnerState(renderState) {
+                error = renderState.error;
+                if (renderState.error) {
+                    // A failed task (including a mid-stream `error` event) must not leave
+                    // any streamed partial visible.
+                    suggestions = [];
+                } else if (renderState.isLoading || renderState.output !== undefined) {
+                    // Only adopt the inner output once a request is loading or has
+                    // produced one, so the initial no-op render doesn't clobber pills.
+                    suggestions = parseSuggestions(renderState.output);
+                }
+                isLoading = renderState.isLoading;
+                if (!latestRenderOptions) return;
+                renderOutward(latestRenderOptions);
+            };
             var fetchAndRender = function fetchAndRender(results, renderOptions) {
+                var _ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _ref_force = _ref.force, force = _ref_force === void 0 ? false : _ref_force;
+                var _buildPageContext;
                 var _results_hits;
                 if (disposed || !tasksState) return;
+                var hadDroppedInnerRender = droppedInnerRender;
                 refetchPending = false;
-                var hasContext = context !== undefined;
-                if (!hasContext && !(results === null || results === void 0 ? void 0 : (_results_hits = results.hits) === null || _results_hits === void 0 ? void 0 : _results_hits.length)) {
+                droppedInnerRender = false;
+                var resolvedContext = resolveContext();
+                var input = (_buildPageContext = buildPageContext(resolvedContext, results)) !== null && _buildPageContext !== void 0 ? _buildPageContext : {};
+                // Two ways there is nothing worth sending: no context for this fetch and
+                // no hits to derive one from, or a context that resolved to something
+                // empty. The first reads the resolved value rather than the option, so
+                // `context: () => undefined` is gated exactly like an omitted `context`.
+                // Sending an empty input spends a model call on no information.
+                if (resolvedContext === undefined && !(results === null || results === void 0 ? void 0 : (_results_hits = results.hits) === null || _results_hits === void 0 ? void 0 : _results_hits.length) || Object.keys(input).length === 0) {
                     tasksState.invalidate();
                     suggestions = [];
                     isLoading = false;
+                    // The output is gone, so the same payload must be allowed to rebuild it.
+                    lastSubmittedPayload = null;
                     renderOutward(renderOptions);
                     return;
                 }
-                tasksState.submit(buildInput(results));
+                var payload = taskPayloadKey(input);
+                // A moved search state does not always mean a different question: with an
+                // explicit `context` the payload ignores the results entirely, so a new
+                // `queryID` or a new hit order produces a byte-identical request. Sending
+                // it again spends a model call on an answer already on screen. Leave the
+                // current suggestions alone and send nothing. `force` is the explicit
+                // path (`refresh()`), which must always reach the network.
+                if (!force && payload !== null && payload === lastSubmittedPayload) {
+                    // Nothing goes out, so nothing will render — but the state change that
+                    // scheduled this fetch also made `handleInnerRender` drop the render
+                    // that was carrying the previous request's result. Reconcile it here or
+                    // the widget keeps that request's `isLoading: true` with no
+                    // suggestions, and nothing later clears it: `refresh()` is blocked by
+                    // its own `isLoading` guard and an unchanged payload keeps skipping.
+                    if (hadDroppedInnerRender) {
+                        adoptInnerState(tasksState);
+                    }
+                    return;
+                }
+                lastSubmittedPayload = payload;
+                tasksState.submit(input);
             };
             var refresh = function refresh() {
                 if (isLoading) return;
-                var results = latestRenderOptions === null || latestRenderOptions === void 0 ? void 0 : latestRenderOptions.results;
-                if (!results || !latestRenderOptions) return;
+                if (!latestRenderOptions) return;
+                var results = getLatestResults();
                 clearTimeout(debounceTimer);
-                lastStateSignature = getStateSignature(results);
-                fetchAndRender(results, latestRenderOptions);
+                // Only meaningful with results: without them there is no signature for a
+                // later automatic fetch to compare against.
+                if (results) {
+                    lastStateSignature = getStateSignature(results);
+                }
+                fetchAndRender(results, latestRenderOptions, {
+                    force: true
+                });
             };
             var getWidgetRenderState = function getWidgetRenderState(renderOptions) {
                 var results = 'results' in renderOptions ? renderOptions.results : undefined;
@@ -16255,12 +16545,17 @@
                 var chatRenderState = getChatRenderState(renderOptions);
                 var isChatBusy$1 = chatRenderState ? !chatRenderState.sendMessage || isChatBusy(chatRenderState) : false;
                 var send = sendToChat(renderOptions);
+                // `sendToChat` is withheld only once the mount window has closed: a chat
+                // widget further down a React tree is added after this widget's `init`,
+                // so until `validateChat` runs its absence is not yet conclusive and
+                // withholding the handler would make a valid setup look broken.
+                var canSendToChat = Boolean(chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.sendMessage) || !hasValidatedChat;
                 return {
                     suggestions: transformed,
                     isLoading: isLoading,
                     error: error,
-                    onSuggestionClick: send,
-                    sendToChat: send,
+                    onSuggestionClick: canSendToChat ? send : noop,
+                    sendToChat: canSendToChat ? send : undefined,
                     refresh: refresh,
                     isChatBusy: isChatBusy$1,
                     widgetParams: widgetParams
@@ -16270,21 +16565,37 @@
             // resolve/error) into this widget's state and re-renders on the client.
             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.
-                    suggestions = [];
-                } else if (renderState.isLoading || renderState.output !== undefined) {
-                    // Only adopt the inner output once a request is loading or has
-                    // produced one, so the initial no-op render doesn't clobber pills.
-                    suggestions = parseSuggestions(renderState.output);
+                    // Keep a failed payload retryable: without this the next automatic
+                    // attempt with the same payload would be skipped as a duplicate and
+                    // the error would have no way to clear. Set before the `refetchPending`
+                    // return so a failure that lands mid-refetch is not swallowed.
+                    lastSubmittedPayload = null;
+                }
+                if (refetchPending) {
+                    droppedInnerRender = true;
+                    return;
                 }
-                isLoading = renderState.isLoading;
-                if (!latestRenderOptions) return;
-                renderOutward(latestRenderOptions);
+                adoptInnerState(renderState);
             };
+            // Deferred because a chat widget can be registered after this one: React
+            // adds widgets in mount order, so a `chat` further down the tree only
+            // lands after this widget's `init` has run. Until this closes the window,
+            // `sendToChat` is handed out optimistically.
+            var validateChat = defer(function(renderOptions) {
+                var _getChatRenderState;
+                if (hasValidatedChat) return;
+                hasValidatedChat = true;
+                if ((_getChatRenderState = getChatRenderState(renderOptions)) === null || _getChatRenderState === void 0 ? void 0 : _getChatRenderState.sendMessage) return;
+                // A render may already have gone out with the optimistic `sendToChat`;
+                // re-render so the widget layer sees the settled answer. The `init()`
+                // options don't count: nothing has painted yet, so the next render
+                // carries it — and a mount that never renders results shows no pills
+                // to mislead anyone.
+                if (latestRenderOptions && 'results' in latestRenderOptions) {
+                    renderOutward(latestRenderOptions);
+                }
+            });
             var tasksParams;
             if (agentId) {
                 tasksParams = {
@@ -16307,12 +16618,37 @@
             var tasksWidget = connectTasks(handleInnerRender, noop)(tasksParams);
             return {
                 $$type: 'ais.promptSuggestions',
+                // Clicking a suggestion opens the chat, so this widget counts as an
+                // entry point for `connectChat`'s trigger validation.
+                opensChat: true,
                 init: function init(initOptions) {
                     var instantSearchInstance = initOptions.instantSearchInstance;
                     tasksWidget.init(initOptions);
+                    // Set after the inner init so its initial no-op render is still
+                    // ignored, and before the first outward render so `refresh()` has a
+                    // render target even on a mount where `render()` never sees results.
+                    latestRenderOptions = initOptions;
+                    validateChat(initOptions);
                     renderFn(_object_spread_props(_object_spread({}, getWidgetRenderState(initOptions)), {
                         instantSearchInstance: instantSearchInstance
                     }), true);
+                    // With an explicit `context` the payload never reads the results, so
+                    // waiting for a search is waiting on something the request does not
+                    // use — and a page that triggers no search (a `searchFunction` query
+                    // gate, or a mount made only for the widgets) would wait forever.
+                    // Fetch here instead, after the first render so the `isFirstRender`
+                    // one still arrives first.
+                    //
+                    // There are no results yet by definition, so "is there anything to
+                    // send" reduces to "did the context resolve to something". Checking it
+                    // here rather than letting `fetchAndRender` reject the call keeps init
+                    // out of the "nothing to send" branch, whose `invalidate()` would add
+                    // two outward renders to every mount that has no context — leaving the
+                    // auto-extracted path, the one that does need results, untouched.
+                    var initialContext = resolveContext();
+                    if (initialContext && Object.keys(initialContext).length > 0) {
+                        fetchAndRender(null, initOptions);
+                    }
                 },
                 render: function render(renderOptions) {
                     var results = renderOptions.results, instantSearchInstance = renderOptions.instantSearchInstance;
@@ -16330,8 +16666,9 @@
                         error = undefined;
                         clearTimeout(debounceTimer);
                         debounceTimer = setTimeout(function() {
-                            if (latestRenderOptions === null || latestRenderOptions === void 0 ? void 0 : latestRenderOptions.results) {
-                                fetchAndRender(latestRenderOptions.results, latestRenderOptions);
+                            var latestResults = getLatestResults();
+                            if (latestResults && latestRenderOptions) {
+                                fetchAndRender(latestResults, latestRenderOptions);
                             }
                         }, DEBOUNCE_MS);
                     }
@@ -16342,6 +16679,7 @@
                 dispose: function dispose(disposeOptions) {
                     disposed = true;
                     clearTimeout(debounceTimer);
+                    validateChat.cancel();
                     tasksWidget.dispose(disposeOptions);
                     unmountFn();
                 },