react-instantsearch 7.48.0 → 7.49.0

package/dist/umd/ReactInstantSearch.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch 7.48.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch 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.48.0';
+    var version$2 = '7.49.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -9392,7 +9392,7 @@
         });
     }
 
-    var version = '4.115.0';
+    var version = '4.116.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -14580,6 +14580,7 @@
             var translations = _object_spread({
                 messageLabel: 'Message',
                 actionsLabel: 'Message actions',
+                toolErrorRetryText: 'Retry',
                 reasoningLabel: 'Reasoning'
             }, userTranslations);
             // A message rendered without a connector-attached store falls back to
@@ -14615,7 +14616,11 @@
             var isReasoningStreaming = reasoningParts.some(function(part) {
                 return part.isStreaming;
             });
-            var showActions = Boolean(actions.length > 0 || ActionsComponent) && status === 'ready';
+            // `status` is the chat's, not the row's: gating every row on it took the
+            // actions off completed answers the moment a follow-up turn started,
+            // reflowing rows the turn hasn't touched. Only the row the turn is
+            // producing waits for the status to settle.
+            var showActions = Boolean(actions.length > 0 || ActionsComponent) && (status === 'ready' || !isCurrentMessage);
             var cssClasses = {
                 root: cx('ais-ChatMessage', "ais-ChatMessage--".concat(side), "ais-ChatMessage--".concat(variant), autoHideActions && 'ais-ChatMessage--auto-hide-actions', classNames.root),
                 container: cx('ais-ChatMessage-container', classNames.container),
@@ -14674,11 +14679,7 @@
                     });
                 }
                 if (part.type === 'text') {
-                    // Back-compat shim for sessions started before the move from a
-                    // `<context>{...}</context>` text part to `metadata.turnContext`.
-                    // Safe to remove once existing sessionStorage transcripts have
-                    // rolled over (~2 weeks after release).
-                    if (part.text.startsWith('<context>') && part.text.endsWith('</context>')) {
+                    if (isPartTextEmpty(part)) {
                         return null;
                     }
                     if (TextComponent) {
@@ -14740,7 +14741,30 @@
                             return null;
                         }
                         if (!ToolLayoutComponent) {
-                            return null;
+                            if (toolMessage.state !== 'output-error') {
+                                return null;
+                            }
+                            var messageIndex = messages.findIndex(function(candidate) {
+                                return candidate.id === message.id;
+                            });
+                            var canRetry = tool.retryOnError === true && Boolean(tool.onToolCall) && status === 'ready' && messageIndex >= 0 && !messages.slice(messageIndex + 1).some(function(candidate) {
+                                return candidate.role === 'user';
+                            });
+                            return /*#__PURE__*/ createElement("div", {
+                                key: "".concat(message.id, "-").concat(index),
+                                className: "ais-ChatMessage-tool ais-ChatMessage-toolError"
+                            }, /*#__PURE__*/ createElement("span", {
+                                className: "ais-ChatMessage-toolError-message"
+                            }, toolMessage.errorText || 'Tool call failed.'), canRetry && /*#__PURE__*/ createElement(Button, {
+                                variant: "primary",
+                                size: "sm",
+                                className: "ais-ChatMessage-toolError-action",
+                                onClick: function onClick() {
+                                    return context.onReload(message.id);
+                                }
+                            }, /*#__PURE__*/ createElement(ReloadIcon, {
+                                createElement: createElement
+                            }), translations.toolErrorRetryText));
                         }
                         var toolSendEvent = tool.sendEvent || function() {};
                         var agentId = (_tool_insightsEventContext = tool.insightsEventContext) === null || _tool_insightsEventContext === void 0 ? void 0 : _tool_insightsEventContext.agentId;
@@ -14776,6 +14800,13 @@
                 }
                 return null;
             }
+            var renderedParts = message.parts.map(renderMessagePart);
+            var hasRenderedParts = renderedParts.some(function(part) {
+                return part != null;
+            });
+            if (!hasRenderedParts && !loaderElement && !(ActionsComponent && showActions) && !FooterComponent) {
+                return suggestionsElement !== null && suggestionsElement !== void 0 ? suggestionsElement : null;
+            }
             return /*#__PURE__*/ createElement("article", _object_spread_props(_object_spread({}, props), {
                 className: cx(cssClasses.root, props.className),
                 "aria-label": translations.messageLabel
@@ -14787,7 +14818,7 @@
                 className: cx(cssClasses.content)
             }, /*#__PURE__*/ createElement("div", {
                 className: cx(cssClasses.message)
-            }, message.parts.map(renderMessagePart), loaderElement), suggestionsElement, showActions && /*#__PURE__*/ createElement("div", {
+            }, renderedParts, loaderElement), suggestionsElement, showActions && /*#__PURE__*/ createElement("div", {
                 className: cx(cssClasses.actions),
                 "aria-label": translations.actionsLabel
             }, ActionsComponent ? /*#__PURE__*/ createElement(ActionsComponent, {
@@ -15527,9 +15558,13 @@
         if (status !== 'submitted' && status !== 'streaming') return false;
         if (status === 'submitted') return true;
         var lastMessage = messages[messages.length - 1];
+        // `processStream` sets `streaming` before the `start` chunk pushes the
+        // assistant. Until then the last message is still the user's, and its text
+        // must not be read as the answer or the loader hides and comes back.
+        if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) !== 'assistant') return true;
         // Parts that render nothing must not answer for the turn's progress, or the
         // loader flips on a part that changed nothing on screen.
-        var lastPart = findLastProgressPart(lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.parts);
+        var lastPart = findLastProgressPart(lastMessage.parts);
         if (!lastPart) return true;
         // An active disclosure carries its own progress affordance, so the loader would
         // double it. Settled reasoning still shows it: the answer has not started.
@@ -17919,6 +17954,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;
@@ -17956,7 +18011,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);
@@ -17969,11 +18024,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);
@@ -18141,7 +18198,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();
@@ -18188,6 +18245,7 @@
             this.onData = onData;
             this.sendAutomaticallyWhen = sendAutomaticallyWhen;
             this.shouldRepairToolInput = shouldRepairToolInput;
+            this.shouldRepairRestoredPendingToolPart = shouldRepairRestoredPendingToolPart;
             this.resolveCancelledToolOutput = resolveCancelledToolOutput;
         }
         _create_class(AbstractChat, [
@@ -18360,7 +18418,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;
                     };
@@ -18375,10 +18433,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
                     });
@@ -18386,6 +18441,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: /**
@@ -18520,18 +18629,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);
                     };
@@ -18915,13 +19024,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);
                                                 });
@@ -19241,7 +19353,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
@@ -19263,8 +19375,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;
@@ -19276,6 +19388,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();
@@ -19294,20 +19407,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);
@@ -19338,19 +19462,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, [
             {
@@ -19386,8 +19505,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$1 = /*#__PURE__*/ function(AbstractChat) {
         _inherits(Chat, AbstractChat);
         function Chat(_0) {
@@ -19403,14 +19522,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;
@@ -19673,6 +19803,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 = 'instantsearch-chat-open-state';
     function normalizePersistence(persistence, hasCustomChat) {
         if (hasCustomChat) {
@@ -20020,7 +20153,8 @@
                 if (!transport) {
                     throw new Error(withUsage$q('You need to provide either an `agentId` or a `transport`.'));
                 }
-                return new Chat$1(_object_spread_props(_object_spread({}, options), {
+                var canRepairRestoredPendingToolParts = !resume;
+                var chat = new Chat$1(_object_spread_props(_object_spread({}, options), {
                     persistence: normalizedPersistence.messages,
                     sendAutomaticallyWhen: sendAutomaticallyWhen,
                     transport: transport,
@@ -20029,6 +20163,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;
@@ -20048,7 +20187,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({
@@ -20058,21 +20197,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',
@@ -20903,9 +21124,6 @@
             return null;
         }
     }
-    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);
-    }
     function stripInternalHitMetadata(hit) {
         var clean = {};
         Object.keys(hit).forEach(function(key) {
@@ -20979,6 +21197,9 @@
             // 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
@@ -21011,21 +21232,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.
@@ -21044,15 +21270,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;
                 }
@@ -21068,6 +21290,16 @@
                 });
                 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)), {
@@ -21093,13 +21325,20 @@
             };
             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;
                 droppedInnerRender = 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)) {
+                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;
@@ -21108,7 +21347,6 @@
                     renderOutward(renderOptions);
                     return;
                 }
-                var input = 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
@@ -21133,10 +21371,14 @@
             };
             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);
+                // 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
                 });
@@ -21150,12 +21392,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
@@ -21178,6 +21425,24 @@
                 }
                 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 = {
@@ -21200,12 +21465,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;
@@ -21223,8 +21513,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);
                     }
@@ -21235,6 +21526,7 @@
                 dispose: function dispose(disposeOptions) {
                     disposed = true;
                     clearTimeout(debounceTimer);
+                    validateChat.cancel();
                     tasksWidget.dispose(disposeOptions);
                     unmountFn();
                 },
@@ -27193,9 +27485,16 @@
         }), {
             $$widgetType: 'ais.promptSuggestions'
         }), suggestions = _usePromptSuggestions.suggestions, isLoading = _usePromptSuggestions.isLoading, error = _usePromptSuggestions.error, onSuggestionClick = _usePromptSuggestions.onSuggestionClick, isChatBusy = _usePromptSuggestions.isChatBusy, sendToChat = _usePromptSuggestions.sendToChat;
+        if (!sendToChat && !onSuggestionClickOverride) {
+            throw new Error('No <Chat> widget is mounted on this index, so there is nothing to send a clicked suggestion to. Mount a <Chat> on the same index, or pass `onSuggestionClick` to handle the click yourself.');
+        }
         var handleClick = onSuggestionClickOverride ? function(prompt) {
             return onSuggestionClickOverride(prompt, {
-                sendToChat: sendToChat
+                // `sendToChat` is only absent when the override above owns the click,
+                // in which case falling through to the chat is a no-op.
+                sendToChat: sendToChat !== null && sendToChat !== void 0 ? sendToChat : function() {
+                    return false;
+                }
             });
         } : onSuggestionClick;
         if (LayoutComponent) {