react-instantsearch-core 7.44.1 → 7.45.0

package/dist/cjs/version.js

@@ -9,4 +9,4 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _default = '7.44.1';
+var _default = '7.45.0';

package/dist/es/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "7.44.1";
+declare const _default: "7.45.0";
 export default _default;

package/dist/es/version.js

@@ -1,3 +1,3 @@
-var version = '7.44.1';
+var version = '7.45.0';
 
 export { version as default };

package/dist/umd/ReactInstantSearchCore.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch Core 7.44.1 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch Core 7.45.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.44.1';
+    var version$2 = '7.45.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -9249,7 +9249,7 @@
         });
     }
 
-    var version = '4.111.1';
+    var version = '4.112.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -12444,6 +12444,68 @@
         return useConnector(connectBreadcrumb, props, additionalWidgetProperties);
     }
 
+    function startsWith(str, prefix) {
+        return str.slice(0, prefix.length) === prefix;
+    }
+
+    var isPartTool = function isPartTool(part) {
+        return startsWith(part.type, 'tool-');
+    };
+
+    var createRecords = function createRecords() {
+        return Object.create(null);
+    };
+    var hasOwn = function hasOwn(records, objectID) {
+        return Object.prototype.hasOwnProperty.call(records, objectID);
+    };
+    function createChatRecordsStore() {
+        var records = createRecords();
+        return {
+            get: function get(objectID) {
+                return hasOwn(records, objectID) ? records[objectID] : undefined;
+            },
+            has: function has(objectID) {
+                return hasOwn(records, objectID);
+            },
+            getAll: function getAll() {
+                return records;
+            },
+            merge: function merge(contributed) {
+                contributed.forEach(function(record) {
+                    if (record && typeof record.objectID === 'string' && record.objectID !== '') {
+                        records[record.objectID] = record;
+                    }
+                });
+            },
+            clear: function clear() {
+                records = createRecords();
+            }
+        };
+    }
+    /**
+     * Collects into `store` the records of every completed tool call in `messages`
+     * whose output holds `hits`. Matching on the output rather than on a tool name
+     * means any tool that fetches records contributes them by returning them.
+     *
+     * Idempotent, so it can re-run over the whole conversation on every update:
+     * streaming deltas and a conversation restored from storage are one code path.
+     */ function collectChatRecords(messages) {
+        var store = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : createChatRecordsStore();
+        messages === null || messages === void 0 ? void 0 : messages.forEach(function(message) {
+            message.parts.forEach(function(part) {
+                var _part_output;
+                if (!isPartTool(part) || part.state !== 'output-available') {
+                    return;
+                }
+                var hits = ((_part_output = part.output) !== null && _part_output !== void 0 ? _part_output : {}).hits;
+                if (Array.isArray(hits)) {
+                    store.merge(hits);
+                }
+            });
+        });
+        return store;
+    }
+
     var tryParseJson = function tryParseJson(value) {
         try {
             return JSON.parse(value);
@@ -12693,7 +12755,17 @@
         var lastMessage = messages[messages.length - 1];
         if (lastMessage.role !== 'assistant') return false;
         if (!lastMessage.parts || lastMessage.parts.length === 0) return false;
-        var toolParts = lastMessage.parts.filter(isToolOrDynamicToolUIPart);
+        // Only the last step of the message counts: earlier steps were answered
+        // before the model was called again, so their resolved tool calls must not
+        // continue the turn a second time.
+        var lastStepStartIndex = lastMessage.parts.reduce(function(lastIndex, part, index) {
+            return part.type === 'step-start' ? index : lastIndex;
+        }, -1);
+        var toolParts = lastMessage.parts.slice(lastStepStartIndex + 1).filter(isToolOrDynamicToolUIPart) // A provider-executed tool call is the provider's to answer, so a turn
+        // made of them is already complete — continuing would resend it.
+        .filter(function(part) {
+            return !part.providerExecuted;
+        });
         if (toolParts.length === 0) return false;
         return toolParts.every(function(part) {
             return part.state === 'output-available' || part.state === 'output-error';
@@ -12796,6 +12868,37 @@
 
     var _computedKey$1;
     var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
+    var TOOL_CALL_CANCELLED_ERROR_TEXT = 'The tool call was cancelled: the conversation moved on before a result was provided.';
+    function getToolName(part) {
+        if (part.type === 'dynamic-tool') {
+            var _part_toolName;
+            return (_part_toolName = part.toolName) !== null && _part_toolName !== void 0 ? _part_toolName : part.type;
+        }
+        return part.type.slice('tool-'.length);
+    }
+    function warnInvalidGlobalToolResult(toolCallId) {}
+    // A tool call awaiting an output that the client owns. Provider-executed calls
+    // are resolved server-side, so they are left alone.
+    function isPendingToolPart(part) {
+        var candidate = part;
+        return typeof candidate.type === 'string' && typeof candidate.toolCallId === 'string' && (candidate.state === 'input-streaming' || candidate.state === 'input-available') && candidate.providerExecuted !== true;
+    }
+    // Drops the fields that only belong to the state being left behind:
+    // `output-error` forbids `output`, and a committed output is not `preliminary`.
+    function withTerminalToolState(part, terminalState) {
+        // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.output; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.errorText;
+        var retainedPart = _object_without_properties(part, [
+            "preliminary",
+            "rawOutput",
+            "output",
+            "errorText"
+        ]);
+        return _object_spread({}, retainedPart, terminalState);
+    }
     _computedKey$1 = /** @internal */ '~addToolResultForMessage';
     var _computedKey1$1 = _computedKey$1;
     /**
@@ -12803,7 +12906,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;
+            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 _this1 = this;
             _class_call_check(this, AbstractChat);
             _define_property(this, "conversationId", void 0);
@@ -12816,6 +12919,7 @@
             _define_property(this, "onData", void 0);
             _define_property(this, "sendAutomaticallyWhen", void 0);
             _define_property(this, "shouldRepairToolInput", void 0);
+            _define_property(this, "resolveCancelledToolOutput", void 0);
             _define_property(this, "activeResponse", null);
             _define_property(this, "latestResponse", null);
             _define_property(this, "responsesByToolCallId", new Map());
@@ -12958,6 +13062,7 @@
        * Add a tool result for a tool call.
        */ _define_property(this, "addToolResult", function(options) {
                 if (!_this.acceptsIdentifierOnlyToolResults) {
+                    warnInvalidGlobalToolResult(options.toolCallId);
                     return Promise.resolve();
                 }
                 var owners = _this.responsesByToolCallId.get(options.toolCallId);
@@ -12972,11 +13077,21 @@
                     });
                     return matchingMessages.length === 1 ? matchingMessages[0] : undefined;
                 };
-                if (!findMatchingMessage()) return Promise.resolve();
+                if (!findMatchingMessage()) {
+                    warnInvalidGlobalToolResult(options.toolCallId);
+                    return Promise.resolve();
+                }
                 return _this.jobExecutor.run(function() {
-                    if (!_this.acceptsIdentifierOnlyToolResults) return Promise.resolve();
+                    if (!_this.acceptsIdentifierOnlyToolResults) {
+                        warnInvalidGlobalToolResult(options.toolCallId);
+                        return Promise.resolve();
+                    }
                     var message = findMatchingMessage();
-                    if (!message || !_this.commit(options.toolCallId, options.output, message.id, undefined, message)) {
+                    if (!message) {
+                        warnInvalidGlobalToolResult(options.toolCallId);
+                        return Promise.resolve();
+                    }
+                    if (!_this.commit(options.toolCallId, options.output, message.id, undefined, message)) {
                         return Promise.resolve();
                     }
                     return _this.continueResponse();
@@ -13023,6 +13138,7 @@
             this.onData = onData;
             this.sendAutomaticallyWhen = sendAutomaticallyWhen;
             this.shouldRepairToolInput = shouldRepairToolInput;
+            this.resolveCancelledToolOutput = resolveCancelledToolOutput;
         }
         _create_class(AbstractChat, [
             {
@@ -13208,15 +13324,8 @@
                     if (!('state' in part) || part.state === 'output-available' && !part.preliminary || part.state === 'output-error') {
                         return false;
                     }
-                    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-                    part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-                    part.rawOutput;
-                    var committedPart = _object_without_properties(part, [
-                        "preliminary",
-                        "rawOutput"
-                    ]);
                     var updatedParts = _to_consumable_array(message.parts);
-                    updatedParts[partIndex] = _object_spread_props(_object_spread({}, committedPart), {
+                    updatedParts[partIndex] = withTerminalToolState(part, {
                         state: 'output-available',
                         output: output
                     });
@@ -13227,6 +13336,60 @@
                     return true;
                 }
             },
+            {
+                key: "getOutboundMessages",
+                value: /**
+       * The transcript to send, with every tool call still awaiting an output
+       * reported as cancelled — a provider rejects a turn holding a tool call with
+       * no matching result.
+       *
+       * The repair stays on this copy rather than being committed to `messages`:
+       * the card is still mounted, so a result submitted after the send must still
+       * land, and is sent as the real output from then on.
+       */ function getOutboundMessages() {
+                    var _this = this;
+                    var outboundMessages;
+                    this.messages.forEach(function(message, messageIndex) {
+                        var repairedParts;
+                        message.parts.forEach(function(part, partIndex) {
+                            if (!isPendingToolPart(part)) return;
+                            repairedParts = repairedParts || _to_consumable_array(message.parts);
+                            repairedParts[partIndex] = withTerminalToolState(part, _this.resolveToolCallCancellation(part));
+                        });
+                        if (repairedParts) {
+                            outboundMessages = outboundMessages || _to_consumable_array(_this.messages);
+                            outboundMessages[messageIndex] = _object_spread_props(_object_spread({}, message), {
+                                parts: repairedParts
+                            });
+                        }
+                    });
+                    return outboundMessages || this.messages;
+                }
+            },
+            {
+                key: "resolveToolCallCancellation",
+                value: function resolveToolCallCancellation(part) {
+                    var cancellation;
+                    // Repairing the outbound transcript must never fail the request build.
+                    try {
+                        var _this_resolveCancelledToolOutput, _this;
+                        cancellation = (_this_resolveCancelledToolOutput = (_this = this).resolveCancelledToolOutput) === null || _this_resolveCancelledToolOutput === void 0 ? void 0 : _this_resolveCancelledToolOutput.call(_this, {
+                            toolName: getToolName(part),
+                            toolCallId: part.toolCallId,
+                            input: 'input' in part ? part.input : undefined
+                        });
+                    } catch (unused) {
+                        cancellation = undefined;
+                    }
+                    return cancellation ? {
+                        state: 'output-available',
+                        output: cancellation.output
+                    } : {
+                        state: 'output-error',
+                        errorText: TOOL_CALL_CANCELLED_ERROR_TEXT
+                    };
+                }
+            },
             {
                 key: "continueResponse",
                 value: function continueResponse(response) {
@@ -13335,10 +13498,13 @@
                     if (!this.transport) {
                         return Promise.reject(new Error('Transport is required for sending messages. Please provide a transport when initializing the chat.'));
                     }
+                    // Resolved as late as possible, so a tool that submits its output in the
+                    // meantime is sent as answered.
+                    var messages = this.getOutboundMessages();
                     return this.consume(function(abortSignal) {
                         return _this.transport.sendMessages({
                             chatId: _this.id,
-                            messages: _this.messages,
+                            messages: messages,
                             abortSignal: abortSignal,
                             trigger: options.trigger,
                             messageId: options.messageId,
@@ -13476,8 +13642,14 @@
                             allowRetired: !wasRetired
                         });
                     };
+                    // A tool call the server answers itself is server-owned, even when the
+                    // stream omits `providerExecuted`: nothing is left for the client to
+                    // submit, so the response must stop requiring a result for it. Dropping it
+                    // from `requiredToolCallIds` also keeps the turn from auto-continuing on
+                    // the server's behalf — a turn made of server-executed tool calls is
+                    // already complete, and resending it would repeat the whole answer.
                     var acceptServerToolResult = function acceptServerToolResult(toolCallId) {
-                        if (response.requiredToolCallIds.has(toolCallId)) {
+                        if (response.requiredToolCallIds.delete(toolCallId)) {
                             response.resolvedToolCallIds.add(toolCallId);
                         }
                     };
@@ -14563,6 +14735,11 @@
                 "requiresSearch"
             ]);
             var normalizedPersistence = normalizePersistence(persistence, 'chat' in options);
+            // Compatibility shim with Algolia MCP Server search tool, which suffixes
+            // the tool name with the index name (`searchIndex_products`).
+            var resolveTool = function resolveTool(toolName) {
+                return tools[toolName] || (toolName.startsWith("".concat(SearchIndexToolType, "_")) ? tools[SearchIndexToolType] : undefined);
+            };
             var _chatInstance;
             var input = '';
             var open = false;
@@ -14574,6 +14751,13 @@
             var setFeedbackState;
             var hasValidatedEntryPoints = false;
             var agentId = 'agentId' in options ? options.agentId : undefined;
+            // Collected here rather than by the tool that searched: that tool renders
+            // nothing while display-results presents its records, and a record has to
+            // outlive the render that produced it.
+            var records = createChatRecordsStore();
+            var collectRecords = function collectRecords() {
+                return collectChatRecords(_chatInstance.messages, records);
+            };
             var feedbackState = {};
             var _sendChatMessageFeedback;
             var feedbackAbortController;
@@ -14614,6 +14798,7 @@
                 // ChatState callbacks that synchronously re-render, so they must run last
                 // for that render to see the cleared feedback and rotated conversation id.
                 feedbackState = {};
+                records.clear();
                 _chatInstance.resetConversationId();
                 setMessages([]);
                 _chatInstance.clearError();
@@ -14634,6 +14819,10 @@
                 });
                 hasValidatedEntryPoints = true;
             };
+            // Deferred because entry points can be registered after the chat itself:
+            // React adds widgets in mount order, so a trigger further down the tree
+            // only lands after this widget's `init` has run.
+            var deferredValidateEntryPoints = defer(validateEntryPoints);
             var makeChatInstance = function makeChatInstance(instantSearchInstance) {
                 // A caller supplied `chat` already owns its transport, so it bypasses the
                 // connector's transport construction and validation below.
@@ -14735,20 +14924,31 @@
                     sendAutomaticallyWhen: sendAutomaticallyWhen,
                     transport: transport,
                     shouldRepairToolInput: function shouldRepairToolInput(toolName) {
-                        var tool = tools[toolName];
-                        if (!tool && toolName.startsWith("".concat(SearchIndexToolType, "_"))) {
-                            tool = tools[SearchIndexToolType];
-                        }
+                        var tool = resolveTool(toolName);
                         if (!tool) return true;
                         return Boolean(tool.streamInput);
                     },
+                    resolveCancelledToolOutput: function resolveCancelledToolOutput(param) {
+                        var toolName = param.toolName, toolCallId = param.toolCallId, input = param.input;
+                        var _resolveTool;
+                        var cancelOutput = (_resolveTool = resolveTool(toolName)) === null || _resolveTool === void 0 ? void 0 : _resolveTool.cancelOutput;
+                        if (!cancelOutput) return undefined;
+                        try {
+                            var output = cancelOutput({
+                                toolCallId: toolCallId,
+                                input: input
+                            });
+                            // `undefined` means the tool declined to provide an output.
+                            return output === undefined ? undefined : {
+                                output: output
+                            };
+                        } catch (unused) {
+                            return undefined;
+                        }
+                    },
                     onToolCall: function onToolCall(param, submitToolResult) {
                         var toolCall = param.toolCall;
-                        var tool = tools[toolCall.toolName];
-                        // Compatibility shim with Algolia MCP Server search tool
-                        if (!tool && toolCall.toolName.startsWith("".concat(SearchIndexToolType, "_"))) {
-                            tool = tools[SearchIndexToolType];
-                        }
+                        var tool = resolveTool(toolCall.toolName);
                         if (!tool) {
                             return submitToolResult({
                                 output: 'No tool implemented for "'.concat(toolCall.toolName, '".'),
@@ -14779,8 +14979,9 @@
                 init: function init(initOptions) {
                     var _this = this;
                     var instantSearchInstance = initOptions.instantSearchInstance;
-                    validateEntryPoints(instantSearchInstance);
+                    deferredValidateEntryPoints(instantSearchInstance);
                     open = normalizedPersistence.open ? readPersistedOpen(type) : false;
+                    records.clear();
                     _chatInstance = makeChatInstance(instantSearchInstance);
                     var render = function render() {
                         renderFn(_object_spread_props(_object_spread({}, _this.getWidgetRenderState(initOptions)), {
@@ -14846,11 +15047,28 @@
                             _chatInstance.messages = initialMessages;
                         }
                     });
+                    // Sibling entry points read `status` through the shared `renderState` to
+                    // disable themselves, so a transition has to escape this widget's own
+                    // render. Message deltas deliberately don't: they stay local to keep
+                    // streaming cheap. The `status` setter notifies on every write, hence
+                    // the comparison.
+                    var lastStatus = _chatInstance.status;
+                    var renderOnStatusChange = function renderOnStatusChange() {
+                        var statusChanged = _chatInstance.status !== lastStatus;
+                        lastStatus = _chatInstance.status;
+                        render();
+                        if (statusChanged) {
+                            initOptions.instantSearchInstance.scheduleRender();
+                        }
+                    };
                     safelyRunOnBrowser(function() {
                         chatSubscriptionUnsubscribers = [
                             _chatInstance['~registerErrorCallback'](render),
+                            // Before `render`, so a delta's records are collected by the time
+                            // the tools of that delta render.
+                            _chatInstance['~registerMessagesCallback'](collectRecords),
                             _chatInstance['~registerMessagesCallback'](render),
-                            _chatInstance['~registerStatusCallback'](render)
+                            _chatInstance['~registerStatusCallback'](renderOnStatusChange)
                         ];
                     });
                     // Resuming and sending reach the network, which a server render must
@@ -14901,6 +15119,9 @@
                     function applyFilters(params) {
                         return updateStateFromSearchToolInput(params, helper);
                     }
+                    // A restored or server-rendered conversation never emitted the messages
+                    // callback above; collecting is idempotent, so covering it here is free.
+                    collectRecords();
                     var insightsEventContext = {
                         agentId: agentId,
                         instantSearchStatus: instantSearchInstance.status
@@ -14913,7 +15134,8 @@
                             '~addToolResultForMessage': _chatInstance['~addToolResultForMessage'],
                             applyFilters: applyFilters,
                             sendEvent: sendEvent,
-                            insightsEventContext: insightsEventContext
+                            insightsEventContext: insightsEventContext,
+                            records: records
                         });
                         toolsWithAddToolResult[key] = toolWithAddToolResult;
                     });
@@ -14958,6 +15180,7 @@
                         suggestions: getSuggestionsFromMessages(_chatInstance.messages),
                         clearMessages: clearMessages,
                         tools: toolsWithAddToolResult,
+                        records: records,
                         sendChatMessageFeedback: _sendChatMessageFeedback,
                         feedbackState: feedbackState,
                         widgetParams: widgetParams,
@@ -14976,6 +15199,7 @@
                     return renderState;
                 },
                 dispose: function dispose() {
+                    deferredValidateEntryPoints.cancel();
                     feedbackAbortController === null || feedbackAbortController === void 0 ? void 0 : feedbackAbortController.abort();
                     unsubscribeChatCallbacks();
                     unmountFn();
@@ -15629,6 +15853,10 @@
         return function(widgetParams) {
             var params = widgetParams !== null && widgetParams !== void 0 ? widgetParams : {};
             var lastOptions = null;
+            function openChatFromTrigger(options) {
+                if (!lastOptions) return false;
+                return openChat(getChatRenderState(lastOptions), options);
+            }
             function toggleOpen() {
                 if (!lastOptions) return;
                 var chatState = getChatRenderState(lastOptions);
@@ -15665,6 +15893,8 @@
                     return {
                         open: (_ref = chatState === null || chatState === void 0 ? void 0 : chatState.open) !== null && _ref !== void 0 ? _ref : false,
                         toggleOpen: toggleOpen,
+                        openChat: openChatFromTrigger,
+                        isChatBusy: chatState ? !chatState.sendMessage || isChatBusy(chatState) : false,
                         widgetParams: params
                     };
                 },