react-instantsearch-core 7.44.1 → 7.46.0

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.46.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.46.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -9249,7 +9249,7 @@
         });
     }
 
-    var version = '4.111.1';
+    var version = '4.113.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -12444,75 +12444,98 @@
         return useConnector(connectBreadcrumb, props, additionalWidgetProperties);
     }
 
-    var tryParseJson = function tryParseJson(value) {
-        try {
-            return JSON.parse(value);
-        } catch (unused) {
-            return undefined;
-        }
+    function startsWith(str, prefix) {
+        return str.slice(0, prefix.length) === prefix;
+    }
+
+    var isPartTool = function isPartTool(part) {
+        return startsWith(part.type, 'tool-');
     };
-    var repairPartialJson = function repairPartialJson(value) {
-        var repaired = value.trim();
-        if (!repaired) {
-            return repaired;
+    var TOOL_PART_PREFIX = 'tool-';
+    /**
+     * Resolves the tool a message part belongs to, from either a part type
+     * (`tool-algolia_search_index`) or a bare tool name.
+     *
+     * Generic over the tool shape so the renderer, the loader and the connector —
+     * which hold different subsets of the tool contract — all resolve names the same
+     * way.
+     */ var findTool = function findTool(partType, tools) {
+        var toolName = startsWith(partType, TOOL_PART_PREFIX) ? partType.slice(TOOL_PART_PREFIX.length) : partType;
+        if (tools[toolName]) {
+            return tools[toolName];
         }
-        var inString = false;
-        var isEscaped = false;
-        var stack = [];
-        for(var index = 0; index < repaired.length; index++){
-            var char = repaired[index];
-            if (inString) {
-                if (isEscaped) {
-                    isEscaped = false;
-                } else if (char === '\\') {
-                    isEscaped = true;
-                } else if (char === '"') {
-                    inString = false;
-                }
-                continue;
-            }
-            if (char === '"') {
-                inString = true;
-                continue;
+        // Compatibility shim for tool names suffixed by the index name, as the Algolia
+        // MCP Server does (`algolia_search_index_products`). The longest matching key
+        // wins, so registering both `foo` and `foo_bar` resolves `foo_bar_products` to
+        // `foo_bar` — otherwise the winner would depend on registration order.
+        var match;
+        Object.keys(tools).forEach(function(key) {
+            if (startsWith(toolName, "".concat(key, "_")) && (match === undefined || key.length > match.length)) {
+                match = key;
             }
-            if (char === '{' || char === '[') {
-                stack.push(char);
-                continue;
-            }
-            if (char === '}' && stack[stack.length - 1] === '{') {
-                stack.pop();
-                continue;
-            }
-            if (char === ']' && stack[stack.length - 1] === '[') {
-                stack.pop();
-            }
-        }
-        if (inString && !isEscaped) {
-            repaired += '"';
-        }
-        repaired = repaired.replace(RegExp(",\\s*$", "u"), '');
-        if (stack.length > 0) {
-            repaired += stack.reverse().map(function(opening) {
-                return opening === '{' ? '}' : ']';
-            }).join('');
-        }
-        return repaired.replace(RegExp(",\\s*([}\\]])", "gu"), '$1');
+        });
+        return match === undefined ? undefined : tools[match];
     };
-    var parsePartialJson = function parsePartialJson(accumulatedRawJson, fallbackValue) {
-        var normalized = accumulatedRawJson.trim();
-        if (!normalized) {
-            return fallbackValue;
-        }
-        var directParsed = tryParseJson(normalized);
-        if (directParsed !== undefined) {
-            return directParsed;
-        }
-        var repairedParsed = tryParseJson(repairPartialJson(normalized));
-        if (repairedParsed !== undefined) {
-            return repairedParsed;
-        }
-        return fallbackValue;
+
+    var 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;
+    }
+
+    function flat(arr) {
+        return arr.reduce(function(acc, array) {
+            return acc.concat(array);
+        }, []);
+    }
 
     /**
      * Stream parser for parsing SSE (Server-Sent Events) streams.
@@ -12693,7 +12716,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';
@@ -12794,328 +12827,632 @@
         return undefined;
     }
 
-    var _computedKey$1;
-    var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
-    _computedKey$1 = /** @internal */ '~addToolResultForMessage';
-    var _computedKey1$1 = _computedKey$1;
     /**
-     * Abstract base class for chat implementations.
-     */ 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 _this1 = this;
-            _class_call_check(this, AbstractChat);
-            _define_property(this, "conversationId", void 0);
-            _define_property(this, "generateId", void 0);
-            _define_property(this, "state", void 0);
-            _define_property(this, "transport", void 0);
-            _define_property(this, "onError", void 0);
-            _define_property(this, "onToolCall", void 0);
-            _define_property(this, "onFinish", void 0);
-            _define_property(this, "onData", void 0);
-            _define_property(this, "sendAutomaticallyWhen", void 0);
-            _define_property(this, "shouldRepairToolInput", void 0);
-            _define_property(this, "activeResponse", null);
-            _define_property(this, "latestResponse", null);
-            _define_property(this, "responsesByToolCallId", new Map());
-            _define_property(this, "responseByMessage", new WeakMap());
-            // 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);
-            _define_property(this, "jobExecutor", new SerialJobExecutor());
-            /**
-       * Appends or replaces a user message to the chat list. This triggers the API call to fetch
-       * the assistant's response.
-       */ _define_property(this, "sendMessage", function(message, options) {
-                return _this.jobExecutor.run(function() {
-                    // Build the user message
-                    var userMessagePromise;
-                    if (message) {
-                        var messageId = message.messageId || _this.generateId();
-                        if ('parts' in message && message.parts) {
-                            // Full message with parts provided
-                            userMessagePromise = Promise.resolve(_object_spread({
-                                id: messageId,
-                                role: 'user'
-                            }, message));
-                        } else if ('text' in message && message.text) {
-                            // Build from text
-                            var parts = [
-                                {
-                                    type: 'text',
-                                    text: message.text
+     * Reads a human-readable message from a failed HTTP response body when the
+     * server returns JSON such as `{ "message": "..." }` (the shared
+     * `ErrorResponse` shape used by every status code), falling back to the HTTP
+     * status line when the body is empty or not parseable.
+     */ function getHttpErrorMessage(response) {
+        var fallback = "HTTP error: ".concat(response.status, " ").concat(response.statusText);
+        return response.text().then(function(text) {
+            var _tryParseErrorMessage;
+            return (_tryParseErrorMessage = tryParseErrorMessage(text)) !== null && _tryParseErrorMessage !== void 0 ? _tryParseErrorMessage : fallback;
+        }).catch(function() {
+            return fallback;
+        });
+    }
+    /**
+     * Abstract base class for HTTP-based chat transports.
+     */ var HttpChatTransport = /*#__PURE__*/ function() {
+        function HttpChatTransport(param) {
+            var _param_api = param.api, api = _param_api === void 0 ? '/api/chat' : _param_api, credentials = param.credentials, headers = param.headers, body = param.body, customFetch = param.fetch, prepareSendMessagesRequest = param.prepareSendMessagesRequest, prepareReconnectToStreamRequest = param.prepareReconnectToStreamRequest;
+            _class_call_check(this, HttpChatTransport);
+            _define_property(this, "api", void 0);
+            _define_property(this, "credentials", void 0);
+            _define_property(this, "headers", void 0);
+            _define_property(this, "body", void 0);
+            _define_property(this, "fetch", void 0);
+            _define_property(this, "prepareSendMessagesRequest", void 0);
+            _define_property(this, "prepareReconnectToStreamRequest", void 0);
+            this.api = api;
+            this.credentials = credentials;
+            this.headers = headers;
+            this.body = body;
+            this.fetch = customFetch;
+            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+            this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
+        }
+        _create_class(HttpChatTransport, [
+            {
+                key: "sendMessages",
+                value: function sendMessages(param) {
+                    var _this = this;
+                    var abortSignal = param.abortSignal, chatId = param.chatId, messages = param.messages, requestMetadata = param.requestMetadata, trigger = param.trigger, messageId = param.messageId, requestHeaders = param.headers, requestBody = param.body;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    // Resolve configurable values
+                    return Promise.all([
+                        resolveValue(this.credentials),
+                        resolveValue(this.headers),
+                        resolveValue(this.body)
+                    ]).then(function(param) {
+                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
+                        // Build default request options
+                        var api = _this.api;
+                        var body = _object_spread({
+                            id: chatId,
+                            messages: messages
+                        }, resolvedBody, requestBody);
+                        var headers = _object_spread({
+                            'Content-Type': 'application/json'
+                        }, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
+                        var credentials = resolvedCredentials;
+                        // Apply custom preparation if provided
+                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
+                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest({
+                            id: chatId,
+                            messages: messages,
+                            requestMetadata: requestMetadata,
+                            body: prepareRequestBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api,
+                            trigger: trigger,
+                            messageId: messageId
+                        })) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                body = prepared.body;
+                                if (prepared.api) api = prepared.api;
+                                if (prepared.headers) {
+                                    headers = _object_spread({
+                                        'Content-Type': 'application/json'
+                                    }, _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers);
                                 }
-                            ];
-                            // Add file parts if provided
-                            if (message.files) {
-                                userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
-                                    var _parts;
-                                    (_parts = parts).push.apply(_parts, _to_consumable_array(fileParts));
-                                    return {
-                                        id: messageId,
-                                        role: 'user',
-                                        parts: parts,
-                                        metadata: message.metadata
-                                    };
-                                });
-                            } else {
-                                userMessagePromise = Promise.resolve({
-                                    id: messageId,
-                                    role: 'user',
-                                    parts: parts,
-                                    metadata: message.metadata
-                                });
+                                if (prepared.credentials) credentials = prepared.credentials;
                             }
-                        } else if ('files' in message && message.files) {
-                            // Files only
-                            userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
-                                return {
-                                    id: messageId,
-                                    role: 'user',
-                                    parts: fileParts,
-                                    metadata: message.metadata
-                                };
+                            return fetchFn(api, {
+                                method: 'POST',
+                                headers: headers,
+                                body: JSON.stringify(body),
+                                signal: abortSignal,
+                                credentials: credentials
+                            }).then(function(response) {
+                                if (!response.ok) {
+                                    return getHttpErrorMessage(response).then(function(message) {
+                                        throw new Error(message);
+                                    });
+                                }
+                                if (!response.body) {
+                                    throw new Error('Response body is empty');
+                                }
+                                return _this.processResponseStream(response.body);
                             });
-                        } else {
-                            userMessagePromise = Promise.resolve(undefined);
-                        }
-                    } else {
-                        userMessagePromise = Promise.resolve(undefined);
-                    }
-                    return userMessagePromise.then(function(userMessage) {
-                        if (userMessage) {
-                            _this.state.pushMessage(userMessage);
-                        }
-                        return _this.makeRequest(_object_spread({
-                            trigger: 'submit-message',
-                            messageId: userMessage === null || userMessage === void 0 ? void 0 : userMessage.id
-                        }, options));
-                    });
-                });
-            });
-            /**
-       * Regenerate the assistant message with the provided message id.
-       * If no message id is provided, the last assistant message will be regenerated.
-       */ _define_property(this, "regenerate", function() {
-                var _0 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : void 0;
-                var _ref = [
-                    _0
-                ], _ref1 = _sliced_to_array(_ref, 1), tmp = _ref1[0], _ref2 = tmp === void 0 ? {} : tmp, messageId = _ref2.messageId, options = _object_without_properties(_ref2, [
-                    "messageId"
-                ]);
-                return _this1.jobExecutor.run(function() {
-                    // Find the message to regenerate from
-                    var targetIndex = -1;
-                    if (messageId) {
-                        targetIndex = _this1.messages.findIndex(function(m) {
-                            return m.id === messageId;
                         });
-                    } else {
-                        // Find the last assistant message
-                        for(var i = _this1.messages.length - 1; i >= 0; i--){
-                            if (_this1.messages[i].role === 'assistant') {
-                                targetIndex = i;
-                                break;
-                            }
-                        }
-                    }
-                    if (targetIndex >= 0) {
-                        // Remove the assistant message and all messages after it
-                        _this1.messages = _this1.messages.slice(0, targetIndex);
-                    }
-                    return _this1.makeRequest(_object_spread({
-                        trigger: 'regenerate-message',
-                        messageId: messageId
-                    }, options));
-                });
-            });
-            /**
-       * Attempt to resume an ongoing streaming response.
-       */ _define_property(this, "resumeStream", function(options) {
-                return _this.jobExecutor.run(function() {
-                    if (!_this.transport) {
-                        return Promise.reject(new Error('Transport is required for resuming stream. Please provide a transport when initializing the chat.'));
-                    }
-                    return _this.consume(function() {
-                        return _this.transport.reconnectToStream(_object_spread({
-                            chatId: _this.id
-                        }, options));
-                    });
-                });
-            });
-            /**
-       * Clear the error state and set the status to ready if the chat is in an error state.
-       */ _define_property(this, "clearError", function() {
-                if (_this.state.status === 'error') {
-                    _this.setStatus({
-                        status: 'ready',
-                        error: undefined
                     });
                 }
-            });
-            /**
-       * Add a tool result for a tool call.
-       */ _define_property(this, "addToolResult", function(options) {
-                if (!_this.acceptsIdentifierOnlyToolResults) {
-                    return Promise.resolve();
-                }
-                var owners = _this.responsesByToolCallId.get(options.toolCallId);
-                var response = (owners === null || owners === void 0 ? void 0 : owners.size) === 1 ? owners.values().next().value : undefined;
-                if (response) return _this.submitToolResult(response, options);
-                var findMatchingMessage = function findMatchingMessage() {
-                    var matchingMessages = _this.messages.filter(function(message) {
-                        var _message_parts;
-                        return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
-                            return 'toolCallId' in part && part.toolCallId === options.toolCallId;
+            },
+            {
+                key: "reconnectToStream",
+                value: function reconnectToStream(param) {
+                    var _this = this;
+                    var chatId = param.chatId, requestHeaders = param.headers, requestBody = param.body;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    // Resolve configurable values
+                    return Promise.all([
+                        resolveValue(this.credentials),
+                        resolveValue(this.headers),
+                        resolveValue(this.body)
+                    ]).then(function(param) {
+                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
+                        // Build default request options
+                        var api = _this.api;
+                        var headers = _object_spread({}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
+                        var credentials = resolvedCredentials;
+                        // Apply custom preparation if provided
+                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
+                        var preparePromise = _this.prepareReconnectToStreamRequest ? Promise.resolve(_this.prepareReconnectToStreamRequest({
+                            id: chatId,
+                            requestMetadata: undefined,
+                            body: prepareRequestBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api
+                        })) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                if (prepared.api) api = prepared.api;
+                                if (prepared.headers) {
+                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
+                                }
+                                if (prepared.credentials) credentials = prepared.credentials;
+                            }
+                            // GET request for reconnection
+                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
+                                method: 'GET',
+                                headers: headers,
+                                credentials: credentials
+                            }).then(function(response) {
+                                if (!response.ok) {
+                                    // 404 means no stream to reconnect to, which is not an error
+                                    if (response.status === 404) {
+                                        return null;
+                                    }
+                                    return getHttpErrorMessage(response).then(function(message) {
+                                        throw new Error(message);
+                                    });
+                                }
+                                if (!response.body) {
+                                    return null;
+                                }
+                                return _this.processResponseStream(response.body);
+                            });
                         });
                     });
-                    return matchingMessages.length === 1 ? matchingMessages[0] : undefined;
-                };
-                if (!findMatchingMessage()) return Promise.resolve();
-                return _this.jobExecutor.run(function() {
-                    if (!_this.acceptsIdentifierOnlyToolResults) return Promise.resolve();
-                    var message = findMatchingMessage();
-                    if (!message || !_this.commit(options.toolCallId, options.output, message.id, undefined, message)) {
-                        return Promise.resolve();
-                    }
-                    return _this.continueResponse();
-                });
-            });
-            _define_property(this, _computedKey1$1, function(message, options) {
-                var hasToolCall = function hasToolCall(candidate) {
-                    var _candidate_parts;
-                    return ((_candidate_parts = candidate.parts) === null || _candidate_parts === void 0 ? void 0 : _candidate_parts.some(function(part) {
-                        return 'toolCallId' in part && part.toolCallId === options.toolCallId;
-                    })) === true;
-                };
-                if (!hasToolCall(message)) {
-                    return Promise.resolve();
-                }
-                var response = _this.responseByMessage.get(message);
-                var currentMessage = _this.messages.includes(message) ? message : response && !response.isRetired ? _this.messages.find(function(candidate) {
-                    return candidate.id === message.id && _this.responseByMessage.get(candidate) === response && hasToolCall(candidate);
-                }) : undefined;
-                if (!currentMessage) return Promise.resolve();
-                return _this.submitToolResult(response, options, currentMessage.id, currentMessage);
-            });
-            /**
-       * Abort the current request immediately, keep the generated tokens if any.
-       */ _define_property(this, "stop", function() {
-                if (_this.activeResponse) {
-                    var response = _this.activeResponse;
-                    response.outcome = 'aborted';
-                    _this.activeResponse = null;
-                    response.abortController.abort();
                 }
-                _this.setStatus({
-                    status: 'ready'
-                });
-                return Promise.resolve();
-            });
-            this.conversationId = id;
-            this.generateId = generateId$1;
-            this.state = state;
-            this.transport = transport;
-            this.onError = onError;
-            this.onToolCall = onToolCall;
-            this.onFinish = onFinish;
-            this.onData = onData;
-            this.sendAutomaticallyWhen = sendAutomaticallyWhen;
-            this.shouldRepairToolInput = shouldRepairToolInput;
+            }
+        ]);
+        return HttpChatTransport;
+    }();
+    /**
+     * Default chat transport implementation using NDJSON streaming.
+     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
+        _inherits(DefaultChatTransport, HttpChatTransport);
+        function DefaultChatTransport() {
+            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            _class_call_check(this, DefaultChatTransport);
+            return _call_super(this, DefaultChatTransport, [
+                options
+            ]);
         }
-        _create_class(AbstractChat, [
-            {
-                key: "id",
-                get: function get() {
-                    return this.conversationId;
-                }
-            },
-            {
-                key: "status",
-                get: /**
-       * Hook status:
-       *
-       * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
-       * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
-       * - `ready`: The full response has been received and processed; a new user message can be submitted.
-       * - `error`: An error occurred during the API request, preventing successful completion.
-       */ function get() {
-                    return this.state.status;
-                }
-            },
+        _create_class(DefaultChatTransport, [
             {
-                key: "setStatus",
-                value: function setStatus(param) {
-                    var status = param.status, error = param.error;
-                    this.state.status = status;
-                    if (error !== undefined) {
-                        this.state.error = error;
-                    }
+                key: "processResponseStream",
+                value: function processResponseStream(stream) {
+                    return parseJsonEventStream(stream);
                 }
-            },
-            {
-                key: "error",
-                get: function get() {
-                    return this.state.error;
+            }
+        ]);
+        return DefaultChatTransport;
+    }(HttpChatTransport);
+
+    var tryParseJson = function tryParseJson(value) {
+        try {
+            return JSON.parse(value);
+        } catch (unused) {
+            return undefined;
+        }
+    };
+    var repairPartialJson = function repairPartialJson(value) {
+        var repaired = value.trim();
+        if (!repaired) {
+            return repaired;
+        }
+        var inString = false;
+        var isEscaped = false;
+        var stack = [];
+        for(var index = 0; index < repaired.length; index++){
+            var char = repaired[index];
+            if (inString) {
+                if (isEscaped) {
+                    isEscaped = false;
+                } else if (char === '\\') {
+                    isEscaped = true;
+                } else if (char === '"') {
+                    inString = false;
                 }
-            },
-            {
-                /**
-       * Starts a new server-side conversation thread by rotating the id sent as
-       * `chatId` / `id` on the next request. The InstantSearch connector calls this
-       * after the user clears the transcript so completions are not tied to prior
-       * context.
-       */ key: "resetConversationId",
-                value: function resetConversationId() {
-                    if (this.responsesByToolCallId.size > 0 || this.messages.some(function(message) {
-                        var _message_parts;
-                        return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
-                            return 'toolCallId' in part;
-                        });
-                    })) {
-                        this.acceptsIdentifierOnlyToolResults = false;
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+                continue;
+            }
+            if (char === '{' || char === '[') {
+                stack.push(char);
+                continue;
+            }
+            if (char === '}' && stack[stack.length - 1] === '{') {
+                stack.pop();
+                continue;
+            }
+            if (char === ']' && stack[stack.length - 1] === '[') {
+                stack.pop();
+            }
+        }
+        if (inString && !isEscaped) {
+            repaired += '"';
+        }
+        repaired = repaired.replace(RegExp(",\\s*$", "u"), '');
+        if (stack.length > 0) {
+            repaired += stack.reverse().map(function(opening) {
+                return opening === '{' ? '}' : ']';
+            }).join('');
+        }
+        return repaired.replace(RegExp(",\\s*([}\\]])", "gu"), '$1');
+    };
+    var parsePartialJson = function parsePartialJson(accumulatedRawJson, fallbackValue) {
+        var normalized = accumulatedRawJson.trim();
+        if (!normalized) {
+            return fallbackValue;
+        }
+        var directParsed = tryParseJson(normalized);
+        if (directParsed !== undefined) {
+            return directParsed;
+        }
+        var repairedParsed = tryParseJson(repairPartialJson(normalized));
+        if (repairedParsed !== undefined) {
+            return repairedParsed;
+        }
+        return fallbackValue;
+    };
+
+    var _computedKey$1;
+    var defaultGuardrailFallbackResponse = 'Sorry, we are not able to generate a response at the moment.';
+    var TOOL_CALL_CANCELLED_ERROR_TEXT = 'The tool call was cancelled: the conversation moved on before a result was provided.';
+    function getToolName(part) {
+        if (part.type === 'dynamic-tool') {
+            var _part_toolName;
+            return (_part_toolName = part.toolName) !== null && _part_toolName !== void 0 ? _part_toolName : part.type;
+        }
+        return part.type.slice('tool-'.length);
+    }
+    function warnInvalidGlobalToolResult(toolCallId) {}
+    // A tool call awaiting an output that the client owns. Provider-executed calls
+    // are resolved server-side, so they are left alone.
+    function isPendingToolPart(part) {
+        var candidate = part;
+        return typeof candidate.type === 'string' && typeof candidate.toolCallId === 'string' && (candidate.state === 'input-streaming' || candidate.state === 'input-available') && candidate.providerExecuted !== true;
+    }
+    // Drops the fields that only belong to the state being left behind:
+    // `output-error` forbids `output`, and a committed output is not `preliminary`.
+    function withTerminalToolState(part, terminalState) {
+        // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.preliminary; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.output; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+        part.errorText;
+        var retainedPart = _object_without_properties(part, [
+            "preliminary",
+            "rawOutput",
+            "output",
+            "errorText"
+        ]);
+        return _object_spread({}, retainedPart, terminalState);
+    }
+    _computedKey$1 = /** @internal */ '~addToolResultForMessage';
+    var _computedKey1$1 = _computedKey$1;
+    /**
+     * Abstract base class for chat implementations.
+     */ 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 _this1 = this;
+            _class_call_check(this, AbstractChat);
+            _define_property(this, "conversationId", void 0);
+            _define_property(this, "generateId", void 0);
+            _define_property(this, "state", void 0);
+            _define_property(this, "transport", void 0);
+            _define_property(this, "onError", void 0);
+            _define_property(this, "onToolCall", void 0);
+            _define_property(this, "onFinish", void 0);
+            _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());
+            _define_property(this, "responseByMessage", new WeakMap());
+            // 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);
+            _define_property(this, "jobExecutor", new SerialJobExecutor());
+            /**
+       * Appends or replaces a user message to the chat list. This triggers the API call to fetch
+       * the assistant's response.
+       */ _define_property(this, "sendMessage", function(message, options) {
+                return _this.jobExecutor.run(function() {
+                    // Build the user message
+                    var userMessagePromise;
+                    if (message) {
+                        var messageId = message.messageId || _this.generateId();
+                        if ('parts' in message && message.parts) {
+                            // Full message with parts provided
+                            userMessagePromise = Promise.resolve(_object_spread({
+                                id: messageId,
+                                role: 'user'
+                            }, message));
+                        } else if ('text' in message && message.text) {
+                            // Build from text
+                            var parts = [
+                                {
+                                    type: 'text',
+                                    text: message.text
+                                }
+                            ];
+                            // Add file parts if provided
+                            if (message.files) {
+                                userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
+                                    var _parts;
+                                    (_parts = parts).push.apply(_parts, _to_consumable_array(fileParts));
+                                    return {
+                                        id: messageId,
+                                        role: 'user',
+                                        parts: parts,
+                                        metadata: message.metadata
+                                    };
+                                });
+                            } else {
+                                userMessagePromise = Promise.resolve({
+                                    id: messageId,
+                                    role: 'user',
+                                    parts: parts,
+                                    metadata: message.metadata
+                                });
+                            }
+                        } else if ('files' in message && message.files) {
+                            // Files only
+                            userMessagePromise = _this.convertFilesToParts(message.files).then(function(fileParts) {
+                                return {
+                                    id: messageId,
+                                    role: 'user',
+                                    parts: fileParts,
+                                    metadata: message.metadata
+                                };
+                            });
+                        } else {
+                            userMessagePromise = Promise.resolve(undefined);
+                        }
+                    } else {
+                        userMessagePromise = Promise.resolve(undefined);
                     }
-                    this.conversationId = this.generateId();
-                }
-            },
-            {
-                key: "messages",
-                get: function get() {
-                    return this.state.messages;
-                },
-                set: function set(messages) {
-                    var _this = this;
-                    var getToolOccurrences = function getToolOccurrences(message) {
-                        return message.parts.filter(function(part) {
-                            return 'toolCallId' in part;
-                        }).map(function(part) {
-                            return {
-                                type: part.type,
-                                toolCallId: part.toolCallId,
-                                state: 'state' in part ? part.state : undefined,
-                                input: 'input' in part ? part.input : undefined,
-                                output: 'output' in part ? part.output : undefined,
-                                errorText: 'errorText' in part ? part.errorText : undefined,
-                                providerExecuted: 'providerExecuted' in part ? part.providerExecuted : undefined
-                            };
-                        });
-                    };
-                    var isEquivalentRehydration = function isEquivalentRehydration(message) {
-                        var replacements = messages.filter(function(candidate) {
-                            return candidate.id === message.id;
+                    return userMessagePromise.then(function(userMessage) {
+                        if (userMessage) {
+                            _this.state.pushMessage(userMessage);
+                        }
+                        return _this.makeRequest(_object_spread({
+                            trigger: 'submit-message',
+                            messageId: userMessage === null || userMessage === void 0 ? void 0 : userMessage.id
+                        }, options));
+                    });
+                });
+            });
+            /**
+       * Regenerate the assistant message with the provided message id.
+       * If no message id is provided, the last assistant message will be regenerated.
+       */ _define_property(this, "regenerate", function() {
+                var _0 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : void 0;
+                var _ref = [
+                    _0
+                ], _ref1 = _sliced_to_array(_ref, 1), tmp = _ref1[0], _ref2 = tmp === void 0 ? {} : tmp, messageId = _ref2.messageId, options = _object_without_properties(_ref2, [
+                    "messageId"
+                ]);
+                return _this1.jobExecutor.run(function() {
+                    // Find the message to regenerate from
+                    var targetIndex = -1;
+                    if (messageId) {
+                        targetIndex = _this1.messages.findIndex(function(m) {
+                            return m.id === messageId;
                         });
-                        if (replacements.length !== 1) return false;
-                        var toolOccurrences = getToolOccurrences(message);
-                        var replacementToolOccurrences = getToolOccurrences(replacements[0]);
-                        return toolOccurrences.length > 0 || replacementToolOccurrences.length > 0 ? isEqual(toolOccurrences, replacementToolOccurrences) : isEqual(message.parts, replacements[0].parts);
-                    };
-                    var detachedResponses = new Set();
-                    this.state.messages.forEach(function(message) {
-                        if (!messages.includes(message)) {
-                            var response = _this.responseByMessage.get(message);
-                            if (response && !isEquivalentRehydration(message)) {
-                                detachedResponses.add(response);
+                    } else {
+                        // Find the last assistant message
+                        for(var i = _this1.messages.length - 1; i >= 0; i--){
+                            if (_this1.messages[i].role === 'assistant') {
+                                targetIndex = i;
+                                break;
+                            }
+                        }
+                    }
+                    if (targetIndex >= 0) {
+                        // Remove the assistant message and all messages after it
+                        _this1.messages = _this1.messages.slice(0, targetIndex);
+                    }
+                    return _this1.makeRequest(_object_spread({
+                        trigger: 'regenerate-message',
+                        messageId: messageId
+                    }, options));
+                });
+            });
+            /**
+       * Attempt to resume an ongoing streaming response.
+       */ _define_property(this, "resumeStream", function(options) {
+                return _this.jobExecutor.run(function() {
+                    if (!_this.transport) {
+                        return Promise.reject(new Error('Transport is required for resuming stream. Please provide a transport when initializing the chat.'));
+                    }
+                    return _this.consume(function() {
+                        return _this.transport.reconnectToStream(_object_spread({
+                            chatId: _this.id
+                        }, options));
+                    });
+                });
+            });
+            /**
+       * Clear the error state and set the status to ready if the chat is in an error state.
+       */ _define_property(this, "clearError", function() {
+                if (_this.state.status === 'error') {
+                    _this.setStatus({
+                        status: 'ready',
+                        error: undefined
+                    });
+                }
+            });
+            /**
+       * 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);
+                var response = (owners === null || owners === void 0 ? void 0 : owners.size) === 1 ? owners.values().next().value : undefined;
+                if (response) return _this.submitToolResult(response, options);
+                var findMatchingMessage = function findMatchingMessage() {
+                    var matchingMessages = _this.messages.filter(function(message) {
+                        var _message_parts;
+                        return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
+                            return 'toolCallId' in part && part.toolCallId === options.toolCallId;
+                        });
+                    });
+                    return matchingMessages.length === 1 ? matchingMessages[0] : undefined;
+                };
+                if (!findMatchingMessage()) {
+                    warnInvalidGlobalToolResult(options.toolCallId);
+                    return Promise.resolve();
+                }
+                return _this.jobExecutor.run(function() {
+                    if (!_this.acceptsIdentifierOnlyToolResults) {
+                        warnInvalidGlobalToolResult(options.toolCallId);
+                        return Promise.resolve();
+                    }
+                    var message = findMatchingMessage();
+                    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();
+                });
+            });
+            _define_property(this, _computedKey1$1, function(message, options) {
+                var hasToolCall = function hasToolCall(candidate) {
+                    var _candidate_parts;
+                    return ((_candidate_parts = candidate.parts) === null || _candidate_parts === void 0 ? void 0 : _candidate_parts.some(function(part) {
+                        return 'toolCallId' in part && part.toolCallId === options.toolCallId;
+                    })) === true;
+                };
+                if (!hasToolCall(message)) {
+                    return Promise.resolve();
+                }
+                var response = _this.responseByMessage.get(message);
+                var currentMessage = _this.messages.includes(message) ? message : response && !response.isRetired ? _this.messages.find(function(candidate) {
+                    return candidate.id === message.id && _this.responseByMessage.get(candidate) === response && hasToolCall(candidate);
+                }) : undefined;
+                if (!currentMessage) return Promise.resolve();
+                return _this.submitToolResult(response, options, currentMessage.id, currentMessage);
+            });
+            /**
+       * Abort the current request immediately, keep the generated tokens if any.
+       */ _define_property(this, "stop", function() {
+                if (_this.activeResponse) {
+                    var response = _this.activeResponse;
+                    response.outcome = 'aborted';
+                    _this.activeResponse = null;
+                    response.abortController.abort();
+                }
+                _this.setStatus({
+                    status: 'ready'
+                });
+                return Promise.resolve();
+            });
+            this.conversationId = id;
+            this.generateId = generateId$1;
+            this.state = state;
+            this.transport = transport;
+            this.onError = onError;
+            this.onToolCall = onToolCall;
+            this.onFinish = onFinish;
+            this.onData = onData;
+            this.sendAutomaticallyWhen = sendAutomaticallyWhen;
+            this.shouldRepairToolInput = shouldRepairToolInput;
+            this.resolveCancelledToolOutput = resolveCancelledToolOutput;
+        }
+        _create_class(AbstractChat, [
+            {
+                key: "id",
+                get: function get() {
+                    return this.conversationId;
+                }
+            },
+            {
+                key: "status",
+                get: /**
+       * Hook status:
+       *
+       * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+       * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+       * - `ready`: The full response has been received and processed; a new user message can be submitted.
+       * - `error`: An error occurred during the API request, preventing successful completion.
+       */ function get() {
+                    return this.state.status;
+                }
+            },
+            {
+                key: "setStatus",
+                value: function setStatus(param) {
+                    var status = param.status, error = param.error;
+                    this.state.status = status;
+                    if (error !== undefined) {
+                        this.state.error = error;
+                    }
+                }
+            },
+            {
+                key: "error",
+                get: function get() {
+                    return this.state.error;
+                }
+            },
+            {
+                /**
+       * Starts a new server-side conversation thread by rotating the id sent as
+       * `chatId` / `id` on the next request. The InstantSearch connector calls this
+       * after the user clears the transcript so completions are not tied to prior
+       * context.
+       */ key: "resetConversationId",
+                value: function resetConversationId() {
+                    if (this.responsesByToolCallId.size > 0 || this.messages.some(function(message) {
+                        var _message_parts;
+                        return (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.some(function(part) {
+                            return 'toolCallId' in part;
+                        });
+                    })) {
+                        this.acceptsIdentifierOnlyToolResults = false;
+                    }
+                    this.conversationId = this.generateId();
+                }
+            },
+            {
+                key: "messages",
+                get: function get() {
+                    return this.state.messages;
+                },
+                set: function set(messages) {
+                    var _this = this;
+                    var getToolOccurrences = function getToolOccurrences(message) {
+                        return message.parts.filter(function(part) {
+                            return 'toolCallId' in part;
+                        }).map(function(part) {
+                            return {
+                                type: part.type,
+                                toolCallId: part.toolCallId,
+                                state: 'state' in part ? part.state : undefined,
+                                input: 'input' in part ? part.input : undefined,
+                                output: 'output' in part ? part.output : undefined,
+                                errorText: 'errorText' in part ? part.errorText : undefined,
+                                providerExecuted: 'providerExecuted' in part ? part.providerExecuted : undefined
+                            };
+                        });
+                    };
+                    var isEquivalentRehydration = function isEquivalentRehydration(message) {
+                        var replacements = messages.filter(function(candidate) {
+                            return candidate.id === message.id;
+                        });
+                        if (replacements.length !== 1) return false;
+                        var toolOccurrences = getToolOccurrences(message);
+                        var replacementToolOccurrences = getToolOccurrences(replacements[0]);
+                        return toolOccurrences.length > 0 || replacementToolOccurrences.length > 0 ? isEqual(toolOccurrences, replacementToolOccurrences) : isEqual(message.parts, replacements[0].parts);
+                    };
+                    var detachedResponses = new Set();
+                    this.state.messages.forEach(function(message) {
+                        if (!messages.includes(message)) {
+                            var response = _this.responseByMessage.get(message);
+                            if (response && !isEquivalentRehydration(message)) {
+                                detachedResponses.add(response);
                             }
                         }
                     });
@@ -13208,15 +13545,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 +13557,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 +13719,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 +13863,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);
                         }
                     };
@@ -13951,489 +14344,248 @@
                                             // Trigger onData callback
                                             if (_this.onData) {
                                                 _this.onData(dataPart);
-                                            }
-                                        }
-                                    }
-                            }
-                        }, function() {
-                            return Promise.all(response.returnedToolCallbacks).then(function() {
-                                return finish();
-                            });
-                        }, function(error) {
-                            return finish(error);
-                        });
-                    });
-                }
-            },
-            {
-                key: "handleError",
-                value: function handleError(error) {
-                    var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_updateState = _ref.updateState, updateState = _ref_updateState === void 0 ? true : _ref_updateState;
-                    if (updateState) {
-                        this.setStatus({
-                            status: 'error',
-                            error: error
-                        });
-                    }
-                    if (this.onError) {
-                        this.onError(error);
-                    }
-                }
-            },
-            {
-                key: "convertFilesToParts",
-                value: function convertFilesToParts(files) {
-                    var _this, _loop = function _loop(i) {
-                        var file = files[i];
-                        promises.push(_this.fileToDataUrl(file).then(function(dataUrl) {
-                            return {
-                                type: 'file',
-                                mediaType: file.type,
-                                filename: file.name,
-                                url: dataUrl
-                            };
-                        }));
-                    };
-                    if (Array.isArray(files)) {
-                        return Promise.resolve(files);
-                    }
-                    var promises = [];
-                    for(var i = 0; i < files.length; i++)_this = this, _loop(i);
-                    return Promise.all(promises);
-                }
-            },
-            {
-                key: "fileToDataUrl",
-                value: function fileToDataUrl(file) {
-                    return new Promise(function(resolve, reject) {
-                        var reader = new FileReader();
-                        reader.onload = function() {
-                            return resolve(reader.result);
-                        };
-                        reader.onerror = reject;
-                        reader.readAsDataURL(file);
-                    });
-                }
-            }
-        ]);
-        return AbstractChat;
-    }();
-
-    var _computedKey, _computedKey1, _computedKey2, _computedKey3, _computedKey4, _computedKey5;
-    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
-    // throws into its own `catch`, so gating it just stops a pointless attempt.
-    function getDefaultInitialMessages(id) {
-        return safelyRunOnBrowser(function() {
-            try {
-                // `sessionStorage` is not available in every environment with a
-                // `window` (e.g. React Native), and some browsers throw on access
-                // when storage is disabled.
-                var initialMessages = sessionStorage.getItem(CACHE_KEY + (id ? "-".concat(id) : ''));
-                return initialMessages ? JSON.parse(initialMessages) : [];
-            } catch (e) {
-                return [];
-            }
-        }, {
-            fallback: function fallback() {
-                return [];
-            }
-        });
-    }
-    _computedKey = '~registerMessagesCallback', _computedKey1 = '~registerStatusCallback', _computedKey2 = '~registerErrorCallback';
-    var _computedKey6 = _computedKey, _computedKey7 = _computedKey1, _computedKey8 = _computedKey2;
-    var ChatState = /*#__PURE__*/ function() {
-        function ChatState() {
-            var _this = this;
-            var id = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : undefined, initialMessages = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : undefined, persistence = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
-            _class_call_check(this, ChatState);
-            _define_property(this, "_messages", void 0);
-            _define_property(this, "_status", 'ready');
-            _define_property(this, "_error", undefined);
-            _define_property(this, "_messagesCallbacks", new Set());
-            _define_property(this, "_statusCallbacks", new Set());
-            _define_property(this, "_errorCallbacks", new Set());
-            _define_property(this, "pushMessage", function(message) {
-                _this._messages = _this._messages.concat(message);
-                _this._callMessagesCallbacks();
-            });
-            _define_property(this, "popMessage", function() {
-                _this._messages = _this._messages.slice(0, -1);
-                _this._callMessagesCallbacks();
-            });
-            _define_property(this, "replaceMessage", function(index, message) {
-                _this._messages = _to_consumable_array(_this._messages.slice(0, index)).concat([
-                    // We deep clone the message here to ensure the new React Compiler (currently in RC) detects deeply nested parts/metadata changes:
-                    _this.snapshot(message)
-                ], _to_consumable_array(_this._messages.slice(index + 1)));
-                _this._callMessagesCallbacks();
-            });
-            _define_property(this, "snapshot", function(thing) {
-                return JSON.parse(JSON.stringify(thing));
-            });
-            _define_property(this, _computedKey6, function(onChange) {
-                var callback = onChange;
-                _this._messagesCallbacks.add(callback);
-                return function() {
-                    _this._messagesCallbacks.delete(callback);
-                };
-            });
-            _define_property(this, _computedKey7, function(onChange) {
-                _this._statusCallbacks.add(onChange);
-                return function() {
-                    _this._statusCallbacks.delete(onChange);
-                };
-            });
-            _define_property(this, _computedKey8, function(onChange) {
-                _this._errorCallbacks.add(onChange);
-                return function() {
-                    _this._errorCallbacks.delete(onChange);
-                };
-            });
-            _define_property(this, "_callMessagesCallbacks", function() {
-                _this._messagesCallbacks.forEach(function(callback) {
-                    return callback();
-                });
-            });
-            _define_property(this, "_callStatusCallbacks", function() {
-                _this._statusCallbacks.forEach(function(callback) {
-                    return callback();
-                });
-            });
-            _define_property(this, "_callErrorCallbacks", function() {
-                _this._errorCallbacks.forEach(function(callback) {
-                    return callback();
-                });
-            });
-            if (initialMessages !== undefined) {
-                this._messages = initialMessages;
-            } else if (persistence) {
-                this._messages = getDefaultInitialMessages(id);
-            } else {
-                this._messages = [];
-            }
-            if (!persistence) {
-                return;
-            }
-            var saveMessagesInLocalStorage = function saveMessagesInLocalStorage() {
-                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['~registerMessagesCallback'](saveMessagesInLocalStorage);
-            this['~registerStatusCallback'](saveMessagesInLocalStorage);
-        }
-        _create_class(ChatState, [
-            {
-                key: "status",
-                get: function get() {
-                    return this._status;
-                },
-                set: function set(newStatus) {
-                    this._status = newStatus;
-                    this._callStatusCallbacks();
-                }
-            },
-            {
-                key: "error",
-                get: function get() {
-                    return this._error;
-                },
-                set: function set(newError) {
-                    this._error = newError;
-                    this._callErrorCallbacks();
-                }
-            },
-            {
-                key: "messages",
-                get: function get() {
-                    return this._messages;
-                },
-                set: function set(newMessages) {
-                    this._messages = _to_consumable_array(newMessages);
-                    this._callMessagesCallbacks();
-                }
-            }
-        ]);
-        return ChatState;
-    }();
-    _computedKey3 = '~registerMessagesCallback', _computedKey4 = '~registerStatusCallback', _computedKey5 = '~registerErrorCallback';
-    var _computedKey9 = _computedKey3, _computedKey10 = _computedKey4, _computedKey11 = _computedKey5;
-    var Chat = /*#__PURE__*/ function(AbstractChat) {
-        _inherits(Chat, AbstractChat);
-        function Chat(_0) {
-            _class_call_check(this, Chat);
-            var _this;
-            var messages = _0.messages, agentId = _0.agentId, _0_persistence = _0.persistence, persistence = _0_persistence === void 0 ? true : _0_persistence, init = _object_without_properties(_0, [
-                "messages",
-                "agentId",
-                "persistence"
-            ]);
-            var state = new ChatState(agentId, messages, persistence);
-            _this = _call_super(this, Chat, [
-                _object_spread_props(_object_spread({}, init), {
-                    state: state
-                })
-            ]), _define_property(_this, "_state", void 0), _define_property(_this, _computedKey9, function(onChange) {
-                return _this._state['~registerMessagesCallback'](onChange);
-            }), _define_property(_this, _computedKey10, function(onChange) {
-                return _this._state['~registerStatusCallback'](onChange);
-            }), _define_property(_this, _computedKey11, function(onChange) {
-                return _this._state['~registerErrorCallback'](onChange);
-            });
-            _this._state = state;
-            return _this;
-        }
-        return Chat;
-    }(AbstractChat);
-
-    // Centralizes the "open the chat from an entry point" behavior shared by the
-    // SearchBox AI button, the Autocomplete AI button, prompt suggestions, and any
-    // future entry point. The chat is always opened; the message is only sent when
-    // it is non-empty and the chat is not already processing a message.
-    // Returns true when a message was submitted, so callers can clear their input.
-    function openChat(chatRenderState) {
-        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, message = _ref.message, referer = _ref.referer, turnContext = _ref.turnContext;
-        var _ref1;
-        var _chatRenderState_setOpen;
-        if (!chatRenderState) {
-            return false;
-        }
-        var trimmed = (_ref1 = message === null || message === void 0 ? void 0 : message.trim()) !== null && _ref1 !== void 0 ? _ref1 : '';
-        if (!trimmed) {
-            if (chatRenderState.focusInput) {
-                chatRenderState.focusInput();
-            } else {
-                var _chatRenderState_setOpen1;
-                (_chatRenderState_setOpen1 = chatRenderState.setOpen) === null || _chatRenderState_setOpen1 === void 0 ? void 0 : _chatRenderState_setOpen1.call(chatRenderState, true);
-            }
-            return false;
-        }
-        (_chatRenderState_setOpen = chatRenderState.setOpen) === null || _chatRenderState_setOpen === void 0 ? void 0 : _chatRenderState_setOpen.call(chatRenderState, true);
-        if (isChatBusy(chatRenderState) || !chatRenderState.sendMessage) {
-            return false;
-        }
-        chatRenderState.sendMessage(_object_spread({
-            text: trimmed
-        }, turnContext ? {
-            metadata: {
-                turnContext: turnContext
-            }
-        } : {}), referer ? {
-            headers: {
-                'x-algolia-referer': referer
-            }
-        } : undefined);
-        return true;
-    }
-    function isChatBusy(chatRenderState) {
-        return (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'submitted' || (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'streaming';
-    }
-
-    var SearchIndexToolType = 'algolia_search_index';
-
-    function flat(arr) {
-        return arr.reduce(function(acc, array) {
-            return acc.concat(array);
-        }, []);
-    }
-
-    /**
-     * Reads a human-readable message from a failed HTTP response body when the
-     * server returns JSON such as `{ "message": "..." }` (the shared
-     * `ErrorResponse` shape used by every status code), falling back to the HTTP
-     * status line when the body is empty or not parseable.
-     */ function getHttpErrorMessage(response) {
-        var fallback = "HTTP error: ".concat(response.status, " ").concat(response.statusText);
-        return response.text().then(function(text) {
-            var _tryParseErrorMessage;
-            return (_tryParseErrorMessage = tryParseErrorMessage(text)) !== null && _tryParseErrorMessage !== void 0 ? _tryParseErrorMessage : fallback;
-        }).catch(function() {
-            return fallback;
-        });
-    }
-    /**
-     * Abstract base class for HTTP-based chat transports.
-     */ var HttpChatTransport = /*#__PURE__*/ function() {
-        function HttpChatTransport(param) {
-            var _param_api = param.api, api = _param_api === void 0 ? '/api/chat' : _param_api, credentials = param.credentials, headers = param.headers, body = param.body, customFetch = param.fetch, prepareSendMessagesRequest = param.prepareSendMessagesRequest, prepareReconnectToStreamRequest = param.prepareReconnectToStreamRequest;
-            _class_call_check(this, HttpChatTransport);
-            _define_property(this, "api", void 0);
-            _define_property(this, "credentials", void 0);
-            _define_property(this, "headers", void 0);
-            _define_property(this, "body", void 0);
-            _define_property(this, "fetch", void 0);
-            _define_property(this, "prepareSendMessagesRequest", void 0);
-            _define_property(this, "prepareReconnectToStreamRequest", void 0);
-            this.api = api;
-            this.credentials = credentials;
-            this.headers = headers;
-            this.body = body;
-            this.fetch = customFetch;
-            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
-            this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
-        }
-        _create_class(HttpChatTransport, [
-            {
-                key: "sendMessages",
-                value: function sendMessages(param) {
-                    var _this = this;
-                    var abortSignal = param.abortSignal, chatId = param.chatId, messages = param.messages, requestMetadata = param.requestMetadata, trigger = param.trigger, messageId = param.messageId, requestHeaders = param.headers, requestBody = param.body;
-                    var _this_fetch;
-                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
-                    // Resolve configurable values
-                    return Promise.all([
-                        resolveValue(this.credentials),
-                        resolveValue(this.headers),
-                        resolveValue(this.body)
-                    ]).then(function(param) {
-                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
-                        // Build default request options
-                        var api = _this.api;
-                        var body = _object_spread({
-                            id: chatId,
-                            messages: messages
-                        }, resolvedBody, requestBody);
-                        var headers = _object_spread({
-                            'Content-Type': 'application/json'
-                        }, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
-                        var credentials = resolvedCredentials;
-                        // Apply custom preparation if provided
-                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
-                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest({
-                            id: chatId,
-                            messages: messages,
-                            requestMetadata: requestMetadata,
-                            body: prepareRequestBody,
-                            credentials: resolvedCredentials,
-                            headers: resolvedHeaders,
-                            api: _this.api,
-                            trigger: trigger,
-                            messageId: messageId
-                        })) : Promise.resolve(null);
-                        return preparePromise.then(function(prepared) {
-                            if (prepared) {
-                                body = prepared.body;
-                                if (prepared.api) api = prepared.api;
-                                if (prepared.headers) {
-                                    headers = _object_spread({
-                                        'Content-Type': 'application/json'
-                                    }, _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers);
-                                }
-                                if (prepared.credentials) credentials = prepared.credentials;
-                            }
-                            return fetchFn(api, {
-                                method: 'POST',
-                                headers: headers,
-                                body: JSON.stringify(body),
-                                signal: abortSignal,
-                                credentials: credentials
-                            }).then(function(response) {
-                                if (!response.ok) {
-                                    return getHttpErrorMessage(response).then(function(message) {
-                                        throw new Error(message);
-                                    });
-                                }
-                                if (!response.body) {
-                                    throw new Error('Response body is empty');
-                                }
-                                return _this.processResponseStream(response.body);
+                                            }
+                                        }
+                                    }
+                            }
+                        }, function() {
+                            return Promise.all(response.returnedToolCallbacks).then(function() {
+                                return finish();
                             });
+                        }, function(error) {
+                            return finish(error);
                         });
                     });
                 }
             },
             {
-                key: "reconnectToStream",
-                value: function reconnectToStream(param) {
-                    var _this = this;
-                    var chatId = param.chatId, requestHeaders = param.headers, requestBody = param.body;
-                    var _this_fetch;
-                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
-                    // Resolve configurable values
-                    return Promise.all([
-                        resolveValue(this.credentials),
-                        resolveValue(this.headers),
-                        resolveValue(this.body)
-                    ]).then(function(param) {
-                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
-                        // Build default request options
-                        var api = _this.api;
-                        var headers = _object_spread({}, _instanceof(resolvedHeaders, Headers) ? Object.fromEntries(resolvedHeaders.entries()) : resolvedHeaders, _instanceof(requestHeaders, Headers) ? Object.fromEntries(requestHeaders.entries()) : requestHeaders);
-                        var credentials = resolvedCredentials;
-                        // Apply custom preparation if provided
-                        var prepareRequestBody = _object_spread({}, resolvedBody, requestBody);
-                        var preparePromise = _this.prepareReconnectToStreamRequest ? Promise.resolve(_this.prepareReconnectToStreamRequest({
-                            id: chatId,
-                            requestMetadata: undefined,
-                            body: prepareRequestBody,
-                            credentials: resolvedCredentials,
-                            headers: resolvedHeaders,
-                            api: _this.api
-                        })) : Promise.resolve(null);
-                        return preparePromise.then(function(prepared) {
-                            if (prepared) {
-                                if (prepared.api) api = prepared.api;
-                                if (prepared.headers) {
-                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
-                                }
-                                if (prepared.credentials) credentials = prepared.credentials;
-                            }
-                            // GET request for reconnection
-                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
-                                method: 'GET',
-                                headers: headers,
-                                credentials: credentials
-                            }).then(function(response) {
-                                if (!response.ok) {
-                                    // 404 means no stream to reconnect to, which is not an error
-                                    if (response.status === 404) {
-                                        return null;
-                                    }
-                                    return getHttpErrorMessage(response).then(function(message) {
-                                        throw new Error(message);
-                                    });
-                                }
-                                if (!response.body) {
-                                    return null;
-                                }
-                                return _this.processResponseStream(response.body);
-                            });
+                key: "handleError",
+                value: function handleError(error) {
+                    var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_updateState = _ref.updateState, updateState = _ref_updateState === void 0 ? true : _ref_updateState;
+                    if (updateState) {
+                        this.setStatus({
+                            status: 'error',
+                            error: error
                         });
+                    }
+                    if (this.onError) {
+                        this.onError(error);
+                    }
+                }
+            },
+            {
+                key: "convertFilesToParts",
+                value: function convertFilesToParts(files) {
+                    var _this, _loop = function _loop(i) {
+                        var file = files[i];
+                        promises.push(_this.fileToDataUrl(file).then(function(dataUrl) {
+                            return {
+                                type: 'file',
+                                mediaType: file.type,
+                                filename: file.name,
+                                url: dataUrl
+                            };
+                        }));
+                    };
+                    if (Array.isArray(files)) {
+                        return Promise.resolve(files);
+                    }
+                    var promises = [];
+                    for(var i = 0; i < files.length; i++)_this = this, _loop(i);
+                    return Promise.all(promises);
+                }
+            },
+            {
+                key: "fileToDataUrl",
+                value: function fileToDataUrl(file) {
+                    return new Promise(function(resolve, reject) {
+                        var reader = new FileReader();
+                        reader.onload = function() {
+                            return resolve(reader.result);
+                        };
+                        reader.onerror = reject;
+                        reader.readAsDataURL(file);
                     });
                 }
             }
         ]);
-        return HttpChatTransport;
+        return AbstractChat;
     }();
-    /**
-     * Default chat transport implementation using NDJSON streaming.
-     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
-        _inherits(DefaultChatTransport, HttpChatTransport);
-        function DefaultChatTransport() {
-            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-            _class_call_check(this, DefaultChatTransport);
-            return _call_super(this, DefaultChatTransport, [
-                options
-            ]);
+
+    var _computedKey, _computedKey1, _computedKey2, _computedKey3, _computedKey4, _computedKey5;
+    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
+    // throws into its own `catch`, so gating it just stops a pointless attempt.
+    function getDefaultInitialMessages(id) {
+        return safelyRunOnBrowser(function() {
+            try {
+                // `sessionStorage` is not available in every environment with a
+                // `window` (e.g. React Native), and some browsers throw on access
+                // when storage is disabled.
+                var initialMessages = sessionStorage.getItem(CACHE_KEY + (id ? "-".concat(id) : ''));
+                return initialMessages ? JSON.parse(initialMessages) : [];
+            } catch (e) {
+                return [];
+            }
+        }, {
+            fallback: function fallback() {
+                return [];
+            }
+        });
+    }
+    _computedKey = '~registerMessagesCallback', _computedKey1 = '~registerStatusCallback', _computedKey2 = '~registerErrorCallback';
+    var _computedKey6 = _computedKey, _computedKey7 = _computedKey1, _computedKey8 = _computedKey2;
+    var ChatState = /*#__PURE__*/ function() {
+        function ChatState() {
+            var _this = this;
+            var id = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : undefined, initialMessages = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : undefined, persistence = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+            _class_call_check(this, ChatState);
+            _define_property(this, "_messages", void 0);
+            _define_property(this, "_status", 'ready');
+            _define_property(this, "_error", undefined);
+            _define_property(this, "_messagesCallbacks", new Set());
+            _define_property(this, "_statusCallbacks", new Set());
+            _define_property(this, "_errorCallbacks", new Set());
+            _define_property(this, "pushMessage", function(message) {
+                _this._messages = _this._messages.concat(message);
+                _this._callMessagesCallbacks();
+            });
+            _define_property(this, "popMessage", function() {
+                _this._messages = _this._messages.slice(0, -1);
+                _this._callMessagesCallbacks();
+            });
+            _define_property(this, "replaceMessage", function(index, message) {
+                _this._messages = _to_consumable_array(_this._messages.slice(0, index)).concat([
+                    // We deep clone the message here to ensure the new React Compiler (currently in RC) detects deeply nested parts/metadata changes:
+                    _this.snapshot(message)
+                ], _to_consumable_array(_this._messages.slice(index + 1)));
+                _this._callMessagesCallbacks();
+            });
+            _define_property(this, "snapshot", function(thing) {
+                return JSON.parse(JSON.stringify(thing));
+            });
+            _define_property(this, _computedKey6, function(onChange) {
+                var callback = onChange;
+                _this._messagesCallbacks.add(callback);
+                return function() {
+                    _this._messagesCallbacks.delete(callback);
+                };
+            });
+            _define_property(this, _computedKey7, function(onChange) {
+                _this._statusCallbacks.add(onChange);
+                return function() {
+                    _this._statusCallbacks.delete(onChange);
+                };
+            });
+            _define_property(this, _computedKey8, function(onChange) {
+                _this._errorCallbacks.add(onChange);
+                return function() {
+                    _this._errorCallbacks.delete(onChange);
+                };
+            });
+            _define_property(this, "_callMessagesCallbacks", function() {
+                _this._messagesCallbacks.forEach(function(callback) {
+                    return callback();
+                });
+            });
+            _define_property(this, "_callStatusCallbacks", function() {
+                _this._statusCallbacks.forEach(function(callback) {
+                    return callback();
+                });
+            });
+            _define_property(this, "_callErrorCallbacks", function() {
+                _this._errorCallbacks.forEach(function(callback) {
+                    return callback();
+                });
+            });
+            if (initialMessages !== undefined) {
+                this._messages = initialMessages;
+            } else if (persistence) {
+                this._messages = getDefaultInitialMessages(id);
+            } else {
+                this._messages = [];
+            }
+            if (!persistence) {
+                return;
+            }
+            var saveMessagesInLocalStorage = function saveMessagesInLocalStorage() {
+                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['~registerMessagesCallback'](saveMessagesInLocalStorage);
+            this['~registerStatusCallback'](saveMessagesInLocalStorage);
         }
-        _create_class(DefaultChatTransport, [
+        _create_class(ChatState, [
             {
-                key: "processResponseStream",
-                value: function processResponseStream(stream) {
-                    return parseJsonEventStream(stream);
+                key: "status",
+                get: function get() {
+                    return this._status;
+                },
+                set: function set(newStatus) {
+                    this._status = newStatus;
+                    this._callStatusCallbacks();
+                }
+            },
+            {
+                key: "error",
+                get: function get() {
+                    return this._error;
+                },
+                set: function set(newError) {
+                    this._error = newError;
+                    this._callErrorCallbacks();
+                }
+            },
+            {
+                key: "messages",
+                get: function get() {
+                    return this._messages;
+                },
+                set: function set(newMessages) {
+                    this._messages = _to_consumable_array(newMessages);
+                    this._callMessagesCallbacks();
                 }
             }
         ]);
-        return DefaultChatTransport;
-    }(HttpChatTransport);
+        return ChatState;
+    }();
+    _computedKey3 = '~registerMessagesCallback', _computedKey4 = '~registerStatusCallback', _computedKey5 = '~registerErrorCallback';
+    var _computedKey9 = _computedKey3, _computedKey10 = _computedKey4, _computedKey11 = _computedKey5;
+    var Chat = /*#__PURE__*/ function(AbstractChat) {
+        _inherits(Chat, AbstractChat);
+        function Chat(_0) {
+            _class_call_check(this, Chat);
+            var _this;
+            var messages = _0.messages, agentId = _0.agentId, _0_persistence = _0.persistence, persistence = _0_persistence === void 0 ? true : _0_persistence, init = _object_without_properties(_0, [
+                "messages",
+                "agentId",
+                "persistence"
+            ]);
+            var state = new ChatState(agentId, messages, persistence);
+            _this = _call_super(this, Chat, [
+                _object_spread_props(_object_spread({}, init), {
+                    state: state
+                })
+            ]), _define_property(_this, "_state", void 0), _define_property(_this, _computedKey9, function(onChange) {
+                return _this._state['~registerMessagesCallback'](onChange);
+            }), _define_property(_this, _computedKey10, function(onChange) {
+                return _this._state['~registerStatusCallback'](onChange);
+            }), _define_property(_this, _computedKey11, function(onChange) {
+                return _this._state['~registerErrorCallback'](onChange);
+            });
+            _this._state = state;
+            return _this;
+        }
+        return Chat;
+    }(AbstractChat);
 
     var withUsage$q = createDocumentationMessageGenerator({
         name: 'chat',
@@ -14574,6 +14726,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;
@@ -14583,21 +14742,44 @@
                     return unsubscribe();
                 });
             };
-            // Extract suggestions from the last assistant message's data-suggestions part
-            var getSuggestionsFromMessages = function getSuggestionsFromMessages(messages) {
-                // Find the last assistant message (iterate from end)
-                var lastAssistantMessage = _to_consumable_array(messages).reverse().find(function(message) {
+            var findSuggestionsPart = function findSuggestionsPart(message) {
+                var _message_parts;
+                return message === null || message === void 0 ? void 0 : (_message_parts = message.parts) === null || _message_parts === void 0 ? void 0 : _message_parts.find(function(part) {
+                    var _part_data;
+                    return 'type' in part && part.type === 'data-suggestions' && 'data' in part && Array.isArray((_part_data = part.data) === null || _part_data === void 0 ? void 0 : _part_data.suggestions);
+                });
+            };
+            var findLastAssistantMessage = function findLastAssistantMessage(messages) {
+                return _to_consumable_array(messages).reverse().find(function(message) {
                     return message.role === 'assistant' && message.parts;
                 });
-                if (!(lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : lastAssistantMessage.parts)) {
-                    return undefined;
+            };
+            // Extract suggestions from the last assistant message's data-suggestions part
+            var getSuggestionsFromMessages = function getSuggestionsFromMessages(messages) {
+                var _findSuggestionsPart;
+                return (_findSuggestionsPart = findSuggestionsPart(findLastAssistantMessage(messages))) === null || _findSuggestionsPart === void 0 ? void 0 : _findSuggestionsPart.data.suggestions;
+            };
+            // "Still coming" has to be inferred: the turn is running and has no
+            // `data-suggestions` part yet. Expecting any at all needs evidence, or an
+            // agent that never sends them would sit under a placeholder forever.
+            var getSuggestionsStatus = function getSuggestionsStatus(messages) {
+                var _lastAssistantMessage_metadata;
+                var status = _chatInstance.status;
+                if (status !== 'submitted' && status !== 'streaming') {
+                    return 'idle';
                 }
-                // Find the data-suggestions part
-                var suggestionsPart = lastAssistantMessage.parts.find(function(part) {
-                    var _part_data;
-                    return 'type' in part && part.type === 'data-suggestions' && 'data' in part && Array.isArray((_part_data = part.data) === null || _part_data === void 0 ? void 0 : _part_data.suggestions);
+                var lastAssistantMessage = findLastAssistantMessage(messages);
+                if (findSuggestionsPart(lastAssistantMessage)) {
+                    return 'idle';
+                }
+                var declaresSuggestions = (lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : (_lastAssistantMessage_metadata = lastAssistantMessage.metadata) === null || _lastAssistantMessage_metadata === void 0 ? void 0 : _lastAssistantMessage_metadata.suggestionsEnabled) === true;
+                if (declaresSuggestions) {
+                    return 'loading';
+                }
+                var hasSuggestionsHistory = messages.some(function(message) {
+                    return message !== lastAssistantMessage && message.role === 'assistant' && Boolean(findSuggestionsPart(message));
                 });
-                return suggestionsPart === null || suggestionsPart === void 0 ? void 0 : suggestionsPart.data.suggestions;
+                return hasSuggestionsHistory ? 'loading' : 'idle';
             };
             var setMessages = function setMessages(messagesParam) {
                 if (typeof messagesParam === 'function') {
@@ -14614,6 +14796,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 +14817,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 +14922,31 @@
                     sendAutomaticallyWhen: sendAutomaticallyWhen,
                     transport: transport,
                     shouldRepairToolInput: function shouldRepairToolInput(toolName) {
-                        var tool = tools[toolName];
-                        if (!tool && toolName.startsWith("".concat(SearchIndexToolType, "_"))) {
-                            tool = tools[SearchIndexToolType];
-                        }
+                        var tool = findTool(toolName, tools);
                         if (!tool) return true;
                         return Boolean(tool.streamInput);
                     },
+                    resolveCancelledToolOutput: function resolveCancelledToolOutput(param) {
+                        var toolName = param.toolName, toolCallId = param.toolCallId, input = param.input;
+                        var _findTool;
+                        var cancelOutput = (_findTool = findTool(toolName, tools)) === null || _findTool === void 0 ? void 0 : _findTool.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 = findTool(toolCall.toolName, tools);
                         if (!tool) {
                             return submitToolResult({
                                 output: 'No tool implemented for "'.concat(toolCall.toolName, '".'),
@@ -14779,8 +14977,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 +15045,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 +15117,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 +15132,8 @@
                             '~addToolResultForMessage': _chatInstance['~addToolResultForMessage'],
                             applyFilters: applyFilters,
                             sendEvent: sendEvent,
-                            insightsEventContext: insightsEventContext
+                            insightsEventContext: insightsEventContext,
+                            records: records
                         });
                         toolsWithAddToolResult[key] = toolWithAddToolResult;
                     });
@@ -14956,8 +15176,10 @@
                         '~isOpenStatePersistenceEnabled': normalizedPersistence.open,
                         setMessages: setMessages,
                         suggestions: getSuggestionsFromMessages(_chatInstance.messages),
+                        suggestionsStatus: getSuggestionsStatus(_chatInstance.messages),
                         clearMessages: clearMessages,
                         tools: toolsWithAddToolResult,
+                        records: records,
                         sendChatMessageFeedback: _sendChatMessageFeedback,
                         feedbackState: feedbackState,
                         widgetParams: widgetParams,
@@ -14976,6 +15198,7 @@
                     return renderState;
                 },
                 dispose: function dispose() {
+                    deferredValidateEntryPoints.cancel();
                     feedbackAbortController === null || feedbackAbortController === void 0 ? void 0 : feedbackAbortController.abort();
                     unsubscribeChatCallbacks();
                     unmountFn();
@@ -15057,44 +15280,30 @@
         });
     }
 
-    function buildEndpoint(param) {
-        var appId = param.appId, agentId = param.agentId;
-        return "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/tasks");
+    function isHeaders$1(headers) {
+        return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
     }
-    function resolveEndpoint(params) {
-        if (params.transport) {
-            return {
-                endpoint: params.transport.api,
-                headers: params.transport.headers || {},
-                prepareSendMessagesRequest: params.transport.prepareSendMessagesRequest
-            };
+    function headersToRecord$1(headers) {
+        if (!headers) {
+            return {};
         }
-        if (!params.appId || !params.apiKey || !params.agentId) {
-            throw new Error('[tasks] Either `transport` or `{ appId, apiKey, agentId }` is required.');
+        if (isHeaders$1(headers)) {
+            return Object.fromEntries(headers.entries());
         }
-        var headers = {
-            'x-algolia-application-id': params.appId,
-            'x-algolia-api-key': params.apiKey
-        };
-        if (params.algoliaAgent) {
-            headers['x-algolia-agent'] = "".concat(params.algoliaAgent, "; tasks");
+        if (Array.isArray(headers)) {
+            return Object.fromEntries(headers);
         }
-        return {
-            endpoint: buildEndpoint({
-                appId: params.appId,
-                agentId: params.agentId
-            }),
-            headers: headers
-        };
+        return headers;
     }
-
-    function buildTaskPayload(param) {
-        var task = param.task, input = param.input, prepareRequest = param.prepareRequest;
-        var payload = {
-            task: task,
-            input: input
-        };
-        return prepareRequest ? prepareRequest(payload).body : payload;
+    function withJsonContentType(headers) {
+        var merged = _object_spread({}, headersToRecord$1(headers));
+        Object.keys(merged).forEach(function(name) {
+            if (name.toLowerCase() === 'content-type') {
+                delete merged[name];
+            }
+        });
+        merged['Content-Type'] = 'application/json';
+        return merged;
     }
     function withStreamParam(url) {
         return url.includes('?') ? "".concat(url, "&stream=true") : "".concat(url, "?stream=true");
@@ -15102,6 +15311,40 @@
     function resolveStreamedOutput(data, previous) {
         return typeof data === 'string' ? parsePartialJson(data, previous) : data;
     }
+    function createTaskPreparationContext(context) {
+        function hideProperty(key) {
+            var value = context[key];
+            Object.defineProperty(context, key, {
+                configurable: true,
+                enumerable: false,
+                get: function get() {
+                    return value;
+                },
+                set: function set(nextValue) {
+                    Reflect.deleteProperty(context, key);
+                    Object.defineProperty(context, key, {
+                        configurable: true,
+                        enumerable: true,
+                        value: nextValue,
+                        writable: true
+                    });
+                }
+            });
+        }
+        // Rich metadata stays out of legacy body spreads until assigned as payload.
+        hideProperty('stream');
+        hideProperty('body');
+        hideProperty('credentials');
+        hideProperty('headers');
+        hideProperty('api');
+        return context;
+    }
+    function unwrap(envelope) {
+        if ((typeof envelope === "undefined" ? "undefined" : _type_of(envelope)) === 'object' && envelope !== null && 'output' in envelope) {
+            return envelope.output;
+        }
+        return undefined;
+    }
     function consumeTaskStream(body, onData) {
         return new Promise(function(resolve, reject) {
             var chunkStream = parseJsonEventStream(body);
@@ -15110,10 +15353,6 @@
                 if (!chunk) {
                     return;
                 }
-                // A terminal `error` event aborts the task: reject rather than let the
-                // stream close and resolve the last partial snapshot as a success.
-                // Throwing here lets `processStream` release the reader and stop
-                // consuming; the rejection propagates to the caller's `.catch`.
                 if (chunk.type === 'error') {
                     throw new Error(chunk.errorText || 'Task stream error');
                 }
@@ -15129,48 +15368,207 @@
             }, reject);
         });
     }
-    function fetchTask(param) {
-        var endpoint = param.endpoint, headers = param.headers, payload = param.payload, onData = param.onData, _param_stream = param.stream, stream = _param_stream === void 0 ? true : _param_stream;
-        return fetch(stream ? withStreamParam(endpoint) : endpoint, {
-            method: 'POST',
-            headers: _object_spread_props(_object_spread({}, headers), {
-                'Content-Type': 'application/json'
-            }),
-            body: JSON.stringify(payload)
-        }).then(function(response) {
-            var _response_headers_get, _response_headers;
-            if (!response.ok) {
-                throw new Error("HTTP error ".concat(response.status));
-            }
-            var contentType = ((_response_headers = response.headers) === null || _response_headers === void 0 ? void 0 : (_response_headers_get = _response_headers.get) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.call(_response_headers, 'content-type')) || '';
-            if (stream && response.body && contentType.includes('text/event-stream')) {
-                return consumeTaskStream(response.body, onData);
+    /** Default HTTP transport for named Tasks requests and task-output streams. */ var DefaultTaskTransport = /*#__PURE__*/ function() {
+        function DefaultTaskTransport() {
+            var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_api = _ref.api, api = _ref_api === void 0 ? '/api/tasks' : _ref_api, credentials = _ref.credentials, headers = _ref.headers, body = _ref.body, customFetch = _ref.fetch, prepareSendMessagesRequest = _ref.prepareSendMessagesRequest;
+            _class_call_check(this, DefaultTaskTransport);
+            _define_property(this, "api", void 0);
+            _define_property(this, "credentials", void 0);
+            _define_property(this, "headers", void 0);
+            _define_property(this, "body", void 0);
+            _define_property(this, "fetch", void 0);
+            _define_property(this, "prepareSendMessagesRequest", void 0);
+            this.api = api;
+            this.credentials = credentials;
+            this.headers = headers;
+            this.body = body;
+            this.fetch = customFetch;
+            this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+        }
+        _create_class(DefaultTaskTransport, [
+            {
+                key: "sendTask",
+                value: function sendTask(param) {
+                    var task = param.task, input = param.input, stream = param.stream, onData = param.onData;
+                    return this.sendTaskRequest({
+                        task: task,
+                        input: input,
+                        stream: stream,
+                        onData: onData ? function(data) {
+                            return onData(unwrap(data));
+                        } : undefined
+                    }).then(unwrap);
+                }
+            },
+            {
+                /** @internal */ key: "sendTaskRequest",
+                value: function sendTaskRequest(param) {
+                    var _this = this;
+                    var task = param.task, input = param.input, stream = param.stream, onData = param.onData;
+                    var _this_fetch;
+                    var fetchFn = (_this_fetch = this.fetch) !== null && _this_fetch !== void 0 ? _this_fetch : fetch;
+                    return Promise.all([
+                        resolveValue(this.credentials),
+                        resolveValue(this.headers),
+                        resolveValue(this.body)
+                    ]).then(function(param) {
+                        var _param = _sliced_to_array(param, 3), resolvedCredentials = _param[0], resolvedHeaders = _param[1], resolvedBody = _param[2];
+                        var api = _this.api;
+                        var credentials = resolvedCredentials;
+                        var headers = withJsonContentType(resolvedHeaders);
+                        var body = _object_spread({
+                            task: task,
+                            input: input
+                        }, resolvedBody);
+                        var preparedBody = resolvedBody ? _object_spread({}, resolvedBody) : undefined;
+                        var preparePromise = _this.prepareSendMessagesRequest ? Promise.resolve(_this.prepareSendMessagesRequest(createTaskPreparationContext({
+                            task: task,
+                            input: input,
+                            stream: stream,
+                            body: preparedBody,
+                            credentials: resolvedCredentials,
+                            headers: resolvedHeaders,
+                            api: _this.api
+                        }))) : Promise.resolve(null);
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                body = prepared.body;
+                                if (prepared.api) {
+                                    api = prepared.api;
+                                }
+                                if (prepared.credentials) {
+                                    credentials = prepared.credentials;
+                                }
+                                if (prepared.headers) {
+                                    headers = withJsonContentType(prepared.headers);
+                                }
+                            }
+                            var request = {
+                                method: 'POST',
+                                headers: headers,
+                                body: JSON.stringify(body)
+                            };
+                            if (credentials !== undefined) {
+                                request.credentials = credentials;
+                            }
+                            return fetchFn(stream ? withStreamParam(api) : api, request).then(function(response) {
+                                var _response_headers_get, _response_headers;
+                                if (!response.ok) {
+                                    throw new Error("HTTP error ".concat(response.status));
+                                }
+                                var contentType = ((_response_headers = response.headers) === null || _response_headers === void 0 ? void 0 : (_response_headers_get = _response_headers.get) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.call(_response_headers, 'content-type')) || '';
+                                if (stream && response.body && contentType.includes('text/event-stream')) {
+                                    return consumeTaskStream(response.body, onData);
+                                }
+                                return response.json();
+                            });
+                        });
+                    });
+                }
             }
-            return response.json();
+        ]);
+        return DefaultTaskTransport;
+    }();
+
+    function buildEndpoint(param) {
+        var appId = param.appId, agentId = param.agentId;
+        return "https://".concat(appId, ".algolia.net/agent-studio/1/agents/").concat(agentId, "/tasks");
+    }
+    function isHeaders(headers) {
+        return !Array.isArray(headers) && 'entries' in headers && typeof headers.entries === 'function';
+    }
+    function headersToRecord(headers) {
+        if (!headers) {
+            return {};
+        }
+        if (isHeaders(headers)) {
+            return Object.fromEntries(headers.entries());
+        }
+        if (Array.isArray(headers)) {
+            return Object.fromEntries(headers);
+        }
+        return _object_spread({}, headers);
+    }
+    function mergeProtectedHeaders(headers, protectedHeaders) {
+        var merged = headersToRecord(headers);
+        Object.entries(protectedHeaders).forEach(function(param) {
+            var _param = _sliced_to_array(param, 2), protectedName = _param[0], value = _param[1];
+            Object.keys(merged).forEach(function(name) {
+                if (name.toLowerCase() === protectedName.toLowerCase()) {
+                    delete merged[name];
+                }
+            });
+            merged[protectedName] = value;
         });
+        return merged;
     }
-    function unwrap(envelope) {
-        return envelope === null || envelope === void 0 ? void 0 : envelope.output;
+    /** @internal */ function createTaskTransport(param) {
+        var _param_transport = param.transport, transport = _param_transport === void 0 ? {} : _param_transport, appId = param.appId, apiKey = param.apiKey, agentId = param.agentId, algoliaAgent = param.algoliaAgent;
+        var _transport_api;
+        if (!agentId) {
+            return new DefaultTaskTransport(transport);
+        }
+        if (!appId || !apiKey) {
+            throw new Error('[tasks] `appId` and `apiKey` are required when `agentId` is provided.');
+        }
+        var protectedHeaders = {
+            'x-algolia-application-id': appId,
+            'x-algolia-api-key': apiKey
+        };
+        if (algoliaAgent) {
+            protectedHeaders['x-algolia-agent'] = "".concat(algoliaAgent, "; tasks");
+        }
+        var originalPrepare = transport.prepareSendMessagesRequest;
+        var prepareSendMessagesRequest = originalPrepare ? function(request) {
+            return Promise.resolve(originalPrepare(request)).then(function(prepared) {
+                return _object_spread_props(_object_spread({}, prepared), {
+                    headers: prepared.headers ? mergeProtectedHeaders(prepared.headers, protectedHeaders) : undefined
+                });
+            });
+        } : undefined;
+        return new DefaultTaskTransport(_object_spread_props(_object_spread({}, transport), {
+            api: (_transport_api = transport.api) !== null && _transport_api !== void 0 ? _transport_api : buildEndpoint({
+                appId: appId,
+                agentId: agentId
+            }),
+            headers: function headers() {
+                return Promise.resolve(resolveValue(transport.headers)).then(function(headers) {
+                    return mergeProtectedHeaders(headers, protectedHeaders);
+                });
+            },
+            prepareSendMessagesRequest: prepareSendMessagesRequest
+        }));
     }
-    function createTaskRunner(param) {
-        var endpoint = param.endpoint, headers = param.headers, task = param.task, _param_stream = param.stream, stream = _param_stream === void 0 ? true : _param_stream, prepareRequest = param.prepareRequest;
+
+    function createTaskRunner(options) {
+        var task = options.task, _options_stream = options.stream, stream = _options_stream === void 0 ? true : _options_stream;
+        var transport;
+        if (options.transport !== undefined) {
+            transport = options.transport;
+        } else {
+            var prepareRequest = options.prepareRequest;
+            transport = new DefaultTaskTransport({
+                api: options.endpoint,
+                headers: options.headers,
+                fetch: options.fetch,
+                prepareSendMessagesRequest: prepareRequest ? function(param) {
+                    var requestTask = param.task, input = param.input;
+                    return prepareRequest({
+                        task: requestTask,
+                        input: input
+                    });
+                } : undefined
+            });
+        }
         return {
-            submit: function submit(variables) {
+            submit: function submit(input) {
                 var onData = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}).onData;
-                var payload = buildTaskPayload({
+                return transport.sendTask({
                     task: task,
-                    input: variables,
-                    prepareRequest: prepareRequest
-                });
-                return fetchTask({
-                    endpoint: endpoint,
-                    headers: headers,
-                    payload: payload,
+                    input: input,
                     stream: stream,
-                    onData: onData ? function(partial) {
-                        return onData(unwrap(partial));
-                    } : undefined
-                }).then(unwrap);
+                    onData: onData
+                });
             }
         };
     }
@@ -15257,31 +15655,28 @@
                 $$type: 'ais.tasks',
                 init: function init(initOptions) {
                     var instantSearchInstance = initOptions.instantSearchInstance;
-                    if (transport) {
-                        var resolved = resolveEndpoint({
-                            transport: transport
-                        });
-                        runner = createTaskRunner({
-                            endpoint: resolved.endpoint,
-                            headers: resolved.headers,
-                            task: task,
-                            stream: stream,
-                            prepareRequest: resolved.prepareSendMessagesRequest
-                        });
-                    } else {
+                    if (agentId) {
                         var _getAppIdAndApiKey = _sliced_to_array(getAppIdAndApiKey(instantSearchInstance.client), 2), appId = _getAppIdAndApiKey[0], apiKey = _getAppIdAndApiKey[1];
                         if (!appId || !apiKey) {
                             throw new Error(withUsage$p('Could not extract Algolia credentials from the search client.'));
                         }
-                        var resolved1 = resolveEndpoint({
+                        var taskTransport = createTaskTransport({
+                            transport: transport,
                             appId: appId,
                             apiKey: apiKey,
                             agentId: agentId,
                             algoliaAgent: getAlgoliaAgent(instantSearchInstance.client)
                         });
                         runner = createTaskRunner({
-                            endpoint: resolved1.endpoint,
-                            headers: resolved1.headers,
+                            transport: taskTransport,
+                            task: task,
+                            stream: stream
+                        });
+                    } else {
+                        runner = createTaskRunner({
+                            transport: createTaskTransport({
+                                transport: transport
+                            }),
                             task: task,
                             stream: stream
                         });
@@ -15308,6 +15703,49 @@
         };
     };
 
+    // Centralizes the "open the chat from an entry point" behavior shared by the
+    // SearchBox AI button, the Autocomplete AI button, prompt suggestions, and any
+    // future entry point. The chat is always opened; the message is only sent when
+    // it is non-empty and the chat is not already processing a message.
+    // Returns true when a message was submitted, so callers can clear their input.
+    function openChat(chatRenderState) {
+        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, message = _ref.message, referer = _ref.referer, turnContext = _ref.turnContext;
+        var _ref1;
+        var _chatRenderState_setOpen;
+        if (!chatRenderState) {
+            return false;
+        }
+        var trimmed = (_ref1 = message === null || message === void 0 ? void 0 : message.trim()) !== null && _ref1 !== void 0 ? _ref1 : '';
+        if (!trimmed) {
+            if (chatRenderState.focusInput) {
+                chatRenderState.focusInput();
+            } else {
+                var _chatRenderState_setOpen1;
+                (_chatRenderState_setOpen1 = chatRenderState.setOpen) === null || _chatRenderState_setOpen1 === void 0 ? void 0 : _chatRenderState_setOpen1.call(chatRenderState, true);
+            }
+            return false;
+        }
+        (_chatRenderState_setOpen = chatRenderState.setOpen) === null || _chatRenderState_setOpen === void 0 ? void 0 : _chatRenderState_setOpen.call(chatRenderState, true);
+        if (isChatBusy(chatRenderState) || !chatRenderState.sendMessage) {
+            return false;
+        }
+        chatRenderState.sendMessage(_object_spread({
+            text: trimmed
+        }, turnContext ? {
+            metadata: {
+                turnContext: turnContext
+            }
+        } : {}), referer ? {
+            headers: {
+                'x-algolia-referer': referer
+            }
+        } : undefined);
+        return true;
+    }
+    function isChatBusy(chatRenderState) {
+        return (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'submitted' || (chatRenderState === null || chatRenderState === void 0 ? void 0 : chatRenderState.status) === 'streaming';
+    }
+
     var withUsage$o = createDocumentationMessageGenerator({
         name: 'prompt-suggestions',
         connector: true
@@ -15549,14 +15987,24 @@
                 if (!latestRenderOptions) return;
                 renderOutward(latestRenderOptions);
             };
-            var tasksWidget = connectTasks(handleInnerRender, noop)(_object_spread_props(_object_spread({}, transport ? {
-                transport: transport
-            } : {
-                agentId: agentId
-            }), {
-                task: configurationId,
-                stream: true
-            }));
+            var tasksParams;
+            if (agentId) {
+                tasksParams = {
+                    agentId: agentId,
+                    transport: transport,
+                    task: configurationId,
+                    stream: true
+                };
+            } else if (transport) {
+                tasksParams = {
+                    transport: transport,
+                    task: configurationId,
+                    stream: true
+                };
+            } else {
+                throw new Error(withUsage$o('The `agentId` option is required unless a custom `transport` is provided.'));
+            }
+            var tasksWidget = connectTasks(handleInnerRender, noop)(tasksParams);
             return {
                 $$type: 'ais.promptSuggestions',
                 init: function init(initOptions) {
@@ -15629,6 +16077,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 +16117,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
                     };
                 },