instantsearch.js 4.86.1 → 4.87.1

package/es/lib/ai-lite/types.d.ts

@@ -0,0 +1,362 @@
+/**
+ * Chat 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.
+ */
+export type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
+export type UIDataTypes = Record<string, unknown>;
+export type UITool = {
+    input: unknown;
+    output: unknown | undefined;
+};
+export type UITools = Record<string, UITool>;
+export type ProviderMetadata = Record<string, Record<string, unknown>>;
+type ValueOf<T> = T[keyof T];
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type TextUIPart = {
+    type: 'text';
+    text: string;
+    state?: 'streaming' | 'done';
+    providerMetadata?: ProviderMetadata;
+};
+export type ReasoningUIPart = {
+    type: 'reasoning';
+    text: string;
+    state?: 'streaming' | 'done';
+    providerMetadata?: ProviderMetadata;
+};
+export type SourceUrlUIPart = {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string;
+    providerMetadata?: ProviderMetadata;
+};
+export type SourceDocumentUIPart = {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+    providerMetadata?: ProviderMetadata;
+};
+export type FileUIPart = {
+    type: 'file';
+    mediaType: string;
+    filename?: string;
+    url: string;
+    providerMetadata?: ProviderMetadata;
+};
+export type StepStartUIPart = {
+    type: 'step-start';
+};
+export type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    [NAME in keyof DATA_TYPES & string]: {
+        type: `data-${NAME}`;
+        id?: string;
+        data: DATA_TYPES[NAME];
+    };
+}>;
+export type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
+    [NAME in keyof TOOLS & string]: {
+        type: `tool-${NAME}`;
+        toolCallId: string;
+    } & ({
+        state: 'input-streaming';
+        input: DeepPartial<TOOLS[NAME]['input']> | undefined;
+        providerExecuted?: boolean;
+        output?: never;
+        errorText?: never;
+    } | {
+        state: 'input-available';
+        input: TOOLS[NAME]['input'];
+        providerExecuted?: boolean;
+        output?: never;
+        errorText?: never;
+        callProviderMetadata?: ProviderMetadata;
+    } | {
+        state: 'output-available';
+        input: TOOLS[NAME]['input'];
+        output: TOOLS[NAME]['output'];
+        errorText?: never;
+        providerExecuted?: boolean;
+        callProviderMetadata?: ProviderMetadata;
+        preliminary?: boolean;
+    } | {
+        state: 'output-error';
+        input: TOOLS[NAME]['input'] | undefined;
+        rawInput?: unknown;
+        output?: never;
+        errorText: string;
+        providerExecuted?: boolean;
+        callProviderMetadata?: ProviderMetadata;
+    });
+}>;
+export type DynamicToolUIPart = {
+    type: 'dynamic-tool';
+    toolName: string;
+    toolCallId: string;
+} & ({
+    state: 'input-streaming';
+    input: unknown | undefined;
+    output?: never;
+    errorText?: never;
+} | {
+    state: 'input-available';
+    input: unknown;
+    output?: never;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+} | {
+    state: 'output-available';
+    input: unknown;
+    output: unknown;
+    errorText?: never;
+    callProviderMetadata?: ProviderMetadata;
+    preliminary?: boolean;
+} | {
+    state: 'output-error';
+    input: unknown;
+    output?: never;
+    errorText: string;
+    callProviderMetadata?: ProviderMetadata;
+});
+export type UIMessagePart<DATA_TYPES extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = TextUIPart | ReasoningUIPart | ToolUIPart<TOOLS> | DynamicToolUIPart | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
+export interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
+    id: string;
+    role: 'system' | 'user' | 'assistant';
+    metadata?: METADATA;
+    parts: Array<UIMessagePart<DATA_PARTS, TOOLS>>;
+}
+export type InferUIMessageMetadata<T extends UIMessage> = T extends UIMessage<infer METADATA> ? METADATA : unknown;
+export type InferUIMessageData<T extends UIMessage> = T extends UIMessage<unknown, infer DATA_TYPES> ? DATA_TYPES : UIDataTypes;
+export type InferUIMessageTools<T extends UIMessage> = T extends UIMessage<unknown, UIDataTypes, infer TOOLS> ? TOOLS : UITools;
+export type InferUIMessageToolCall<UI_MESSAGE extends UIMessage> = ValueOf<{
+    [NAME in keyof InferUIMessageTools<UI_MESSAGE>]: {
+        toolName: NAME & string;
+        toolCallId: string;
+        input: InferUIMessageTools<UI_MESSAGE>[NAME] extends {
+            input: infer INPUT;
+        } ? INPUT : never;
+        dynamic?: false;
+    };
+}> | {
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+    dynamic: true;
+};
+type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    [NAME in keyof DATA_TYPES & string]: {
+        type: `data-${NAME}`;
+        id?: string;
+        data: DATA_TYPES[NAME];
+        transient?: boolean;
+    };
+}>;
+export type UIMessageChunk<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = {
+    type: 'text-start';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'text-delta';
+    delta: string;
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'text-end';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'reasoning-start';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'reasoning-delta';
+    id: string;
+    delta: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'reasoning-end';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'error';
+    errorText: string;
+} | {
+    type: 'tool-input-available';
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+    callProviderMetadata?: ProviderMetadata;
+    providerExecuted?: boolean;
+} | {
+    type: 'tool-input-start';
+    toolName: string;
+    toolCallId: string;
+    input?: unknown;
+    providerExecuted?: boolean;
+} | {
+    type: 'tool-input-delta';
+    toolName: string;
+    toolCallId: string;
+    inputDelta: string;
+} | {
+    type: 'tool-output-available';
+    toolName: string;
+    toolCallId: string;
+    output: unknown;
+    callProviderMetadata?: ProviderMetadata;
+    preliminary?: boolean;
+} | {
+    type: 'tool-error';
+    toolName: string;
+    toolCallId: string;
+    errorText: string;
+    input?: unknown;
+    callProviderMetadata?: ProviderMetadata;
+} | {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string;
+} | {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'file';
+    url: string;
+    mediaType: string;
+} | DataUIMessageChunk<DATA_TYPES> | {
+    type: 'start-step';
+} | {
+    type: 'finish-step';
+} | {
+    type: 'start';
+    messageId?: string;
+    messageMetadata?: METADATA;
+} | {
+    type: 'finish';
+    messageMetadata?: METADATA;
+} | {
+    type: 'abort';
+} | {
+    type: 'message-metadata';
+    messageMetadata: METADATA;
+};
+export type InferUIMessageChunk<T extends UIMessage> = UIMessageChunk<InferUIMessageMetadata<T>, InferUIMessageData<T>>;
+export interface ChatState<UI_MESSAGE extends UIMessage> {
+    status: ChatStatus;
+    error: Error | undefined;
+    messages: UI_MESSAGE[];
+    pushMessage: (message: UI_MESSAGE) => void;
+    popMessage: () => void;
+    replaceMessage: (index: number, message: UI_MESSAGE) => void;
+    snapshot: <T>(thing: T) => T;
+}
+export type ChatRequestOptions = {
+    headers?: Record<string, string> | Headers;
+    body?: object;
+    metadata?: unknown;
+};
+export interface ChatTransport<UI_MESSAGE extends UIMessage> {
+    sendMessages: (options: {
+        chatId: string;
+        messages: UI_MESSAGE[];
+        abortSignal: AbortSignal;
+        requestMetadata?: unknown;
+        trigger: 'submit-message' | 'regenerate-message';
+        messageId?: string;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream: (options: {
+        chatId: string;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
+}
+export type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (options: {
+    id: string;
+    messages: UI_MESSAGE[];
+    requestMetadata: unknown;
+    body: Record<string, unknown> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    api: string;
+} & {
+    trigger: 'submit-message' | 'regenerate-message';
+    messageId: string | undefined;
+}) => {
+    body: object;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+} | PromiseLike<{
+    body: object;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+}>;
+export type PrepareReconnectToStreamRequest = (options: {
+    id: string;
+    requestMetadata: unknown;
+    body: Record<string, unknown> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    api: string;
+}) => {
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+} | PromiseLike<{
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+}>;
+export type Resolvable<T> = T | (() => T) | (() => Promise<T>);
+export type FetchFunction = typeof fetch;
+export type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
+    api?: string;
+    credentials?: Resolvable<RequestCredentials>;
+    headers?: Resolvable<Record<string, string> | Headers>;
+    body?: Resolvable<object>;
+    fetch?: FetchFunction;
+    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+};
+export type IdGenerator = () => string;
+export type ChatOnErrorCallback = (error: Error) => void;
+export type ChatOnToolCallCallback<UI_MESSAGE extends UIMessage = UIMessage> = (options: {
+    toolCall: InferUIMessageToolCall<UI_MESSAGE>;
+}) => void | PromiseLike<void>;
+export type ChatOnFinishCallback<UI_MESSAGE extends UIMessage> = (options: {
+    message: UI_MESSAGE;
+    messages: UI_MESSAGE[];
+    isAbort: boolean;
+    isDisconnect: boolean;
+    isError: boolean;
+}) => void;
+export type ChatOnDataCallback<UI_MESSAGE extends UIMessage> = (dataPart: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => void;
+export interface ChatInit<UI_MESSAGE extends UIMessage> {
+    id?: string;
+    messages?: UI_MESSAGE[];
+    generateId?: IdGenerator;
+    transport?: ChatTransport<UI_MESSAGE>;
+    onError?: ChatOnErrorCallback;
+    onToolCall?: ChatOnToolCallCallback<UI_MESSAGE>;
+    onFinish?: ChatOnFinishCallback<UI_MESSAGE>;
+    onData?: ChatOnDataCallback<UI_MESSAGE>;
+    sendAutomaticallyWhen?: (options: {
+        messages: UI_MESSAGE[];
+    }) => boolean | PromiseLike<boolean>;
+}
+export type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
+    id?: UI_MESSAGE['id'];
+    role?: UI_MESSAGE['role'];
+};
+export {};

package/es/lib/ai-lite/types.js

@@ -0,0 +1 @@
+export {};

package/es/lib/ai-lite/utils.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessage } from './types';
+export declare function generateId(): string;
+export declare function lastAssistantMessageIsCompleteWithToolCalls({ messages, }: {
+    messages: UIMessage[];
+}): boolean;
+export declare class SerialJobExecutor {
+    private queue;
+    private isRunning;
+    run<T>(job: () => Promise<T>): Promise<T>;
+    private processQueue;
+}
+export declare function resolveValue<T>(value: T | (() => T) | (() => Promise<T>) | undefined): Promise<T | undefined>;

package/es/lib/ai-lite/utils.js

@@ -0,0 +1,76 @@
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+export function generateId() {
+  return Math.random().toString(36).substring(2, 9);
+}
+function isToolOrDynamicToolUIPart(part) {
+  if (_typeof(part) !== 'object' || part === null) return false;
+  var p = part;
+  return typeof p.type === 'string' && (p.type.startsWith('tool-') || p.type === 'dynamic-tool');
+}
+export function lastAssistantMessageIsCompleteWithToolCalls(_ref) {
+  var messages = _ref.messages;
+  if (messages.length === 0) return false;
+  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);
+  if (toolParts.length === 0) return false;
+  return toolParts.every(function (part) {
+    return part.state === 'output-available' || part.state === 'output-error';
+  });
+}
+export var SerialJobExecutor = /*#__PURE__*/function () {
+  function SerialJobExecutor() {
+    _classCallCheck(this, SerialJobExecutor);
+    _defineProperty(this, "queue", []);
+    _defineProperty(this, "isRunning", false);
+  }
+  _createClass(SerialJobExecutor, [{
+    key: "run",
+    value: function run(job) {
+      var _this = this;
+      return new Promise(function (resolve, reject) {
+        _this.queue.push(function () {
+          return job().then(function (result) {
+            resolve(result);
+          }, function (error) {
+            reject(error);
+          });
+        });
+        _this.processQueue();
+      });
+    }
+  }, {
+    key: "processQueue",
+    value: function processQueue() {
+      var _this2 = this;
+      if (this.isRunning) return;
+      this.isRunning = true;
+      var processNext = function processNext() {
+        if (_this2.queue.length === 0) {
+          _this2.isRunning = false;
+          return;
+        }
+        var job = _this2.queue.shift();
+        if (job) {
+          job().then(processNext, processNext);
+        }
+      };
+      processNext();
+    }
+  }]);
+  return SerialJobExecutor;
+}();
+export function resolveValue(value) {
+  if (value === undefined) return Promise.resolve(undefined);
+  if (typeof value === 'function') {
+    return Promise.resolve(value());
+  }
+  return Promise.resolve(value);
+}

package/es/lib/chat/chat.d.ts

@@ -1,9 +1,9 @@
-import { AbstractChat } from 'ai';
-import type { UIMessage, ChatState as BaseChatState, ChatStatus, ChatInit } from 'ai';
+import { AbstractChat } from '../ai-lite';
+import type { UIMessage, ChatState as BaseChatState, ChatStatus, ChatInit } from '../ai-lite';
 export type { UIMessage };
 export { AbstractChat };
 export { ChatInit };
-export declare const CACHE_KEY = "instantsearch-chat-initial-messages-";
+export declare const CACHE_KEY = "instantsearch-chat-initial-messages";
 export declare class ChatState<TUiMessage extends UIMessage> implements BaseChatState<TUiMessage> {
     _messages: TUiMessage[];
     _status: ChatStatus;

package/es/lib/chat/chat.js

@@ -23,11 +23,11 @@ function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r),
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import { AbstractChat } from 'ai';
+import { AbstractChat } from "../ai-lite/index.js";
 export { AbstractChat };
-export var CACHE_KEY = 'instantsearch-chat-initial-messages-';
+export var CACHE_KEY = 'instantsearch-chat-initial-messages';
 function getDefaultInitialMessages(id) {
-  var initialMessages = sessionStorage.getItem(CACHE_KEY + id);
+  var initialMessages = sessionStorage.getItem(CACHE_KEY + (id ? "-".concat(id) : ''));
   return initialMessages ? JSON.parse(initialMessages) : [];
 }
 export var ChatState = /*#__PURE__*/function () {
@@ -97,7 +97,7 @@ export var ChatState = /*#__PURE__*/function () {
     var saveMessagesInLocalStorage = function saveMessagesInLocalStorage() {
       if (_this.status === 'ready') {
         try {
-          sessionStorage.setItem(CACHE_KEY + id, JSON.stringify(_this.messages));
+          sessionStorage.setItem(CACHE_KEY + (id ? "-".concat(id) : ''), JSON.stringify(_this.messages));
         } catch (e) {
           // Do nothing if sessionStorage is not available or full
         }

package/es/lib/chat/index.d.ts

@@ -5,3 +5,6 @@ export { ChatState } from './chat';
 export { Chat } from './chat';
 export declare const SearchIndexToolType = "algolia_search_index";
 export declare const RecommendToolType = "algolia_recommend";
+export declare const MemorizeToolType = "algolia_memorize";
+export declare const MemorySearchToolType = "algolia_memory_search";
+export declare const PonderToolType = "algolia_ponder";

package/es/lib/chat/index.js

@@ -2,4 +2,7 @@ export { AbstractChat } from "./chat.js";
 export { ChatState } from "./chat.js";
 export { Chat } from "./chat.js";
 export var SearchIndexToolType = 'algolia_search_index';
-export var RecommendToolType = 'algolia_recommend';
+export var RecommendToolType = 'algolia_recommend';
+export var MemorizeToolType = 'algolia_memorize';
+export var MemorySearchToolType = 'algolia_memory_search';
+export var PonderToolType = 'algolia_ponder';

package/es/lib/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "4.86.1";
+declare const _default: "4.87.1";
 export default _default;

package/es/lib/version.js

@@ -1 +1 @@
-export default '4.86.1';
+export default '4.87.1';

package/es/widgets/autocomplete/autocomplete.d.ts

@@ -1,5 +1,5 @@
 
-import type { AutocompleteConnectorParams, AutocompleteRenderState, AutocompleteWidgetDescription } from '../../connectors/autocomplete/connectAutocomplete';
+import type { AutocompleteConnectorParams, AutocompleteRenderState, AutocompleteWidgetDescription, TransformItemsIndicesConfig } from '../../connectors/autocomplete/connectAutocomplete';
 import type { BaseHit, IndexUiState, IndexWidget, Template, WidgetFactory } from '../../types';
 import type { PlainSearchParameters } from 'algoliasearch-helper';
 import type { AutocompleteClassNames, AutocompleteIndexClassNames, AutocompleteIndexConfig } from 'instantsearch-ui-components';
@@ -79,6 +79,7 @@ type AutocompleteWidgetParams<TItem extends BaseHit> = {
         }>;
         cssClasses?: Partial<AutocompleteIndexClassNames>;
     };
+    transformItems?: (indices: TransformItemsIndicesConfig[]) => TransformItemsIndicesConfig[];
     /**
      * Search parameters to apply to the autocomplete indices.
      */

package/es/widgets/autocomplete/autocomplete.js

@@ -171,7 +171,8 @@ function AutocompleteWrapper(_ref4) {
       query: searchboxQuery,
       showRecent: showRecent,
       indices: indices,
-      indicesConfig: indicesConfig
+      indicesConfig: indicesConfig,
+      suggestionsIndexName: showSuggestions === null || showSuggestions === void 0 ? void 0 : showSuggestions.indexName
     }),
     storage = _useStorage.storage,
     storageHits = _useStorage.storageHits,
@@ -255,18 +256,24 @@ function AutocompleteWrapper(_ref4) {
     });
   }
   indices.forEach(function (_ref8, i) {
-    var _indicesConfig$i$temp;
+    var _currentIndexConfig$t;
     var indexId = _ref8.indexId,
       indexName = _ref8.indexName,
       hits = _ref8.hits;
+    var currentIndexConfig = find(indicesConfig, function (config) {
+      return config.indexName === indexName;
+    });
+    if (!currentIndexConfig) {
+      return;
+    }
     if (!renderState.indexTemplateProps[i]) {
       renderState.indexTemplateProps[i] = prepareTemplateProps({
         defaultTemplates: {},
         templatesConfig: instantSearchInstance.templatesConfig,
-        templates: indicesConfig[i].templates
+        templates: currentIndexConfig.templates
       });
     }
-    var headerComponent = (_indicesConfig$i$temp = indicesConfig[i].templates) !== null && _indicesConfig$i$temp !== void 0 && _indicesConfig$i$temp.header ? function (_ref9) {
+    var headerComponent = (_currentIndexConfig$t = currentIndexConfig.templates) !== null && _currentIndexConfig$t !== void 0 && _currentIndexConfig$t.header ? function (_ref9) {
       var items = _ref9.items;
       return h(TemplateComponent, _extends({}, renderState.indexTemplateProps[i], {
         templateKey: "header",
@@ -306,7 +313,7 @@ function AutocompleteWrapper(_ref4) {
         });
       }),
       getItemProps: getItemProps,
-      classNames: indicesConfig[i].cssClasses
+      classNames: currentIndexConfig.cssClasses
     });
   });
   return h(Autocomplete, _extends({}, getRootProps(), {
@@ -346,6 +353,7 @@ export function EXPERIMENTAL_autocomplete(widgetParams) {
     onSelect = _ref1.onSelect,
     _ref1$templates = _ref1.templates,
     templates = _ref1$templates === void 0 ? {} : _ref1$templates,
+    transformItems = _ref1.transformItems,
     _ref1$cssClasses = _ref1.cssClasses,
     userCssClasses = _ref1$cssClasses === void 0 ? {} : _ref1$cssClasses,
     placeholder = _ref1.placeholder;
@@ -430,7 +438,8 @@ export function EXPERIMENTAL_autocomplete(widgetParams) {
       indexId: indexName
     }).addWidgets([configure(indexSearchParameters || {})]);
   })), [_objectSpread(_objectSpread({}, makeWidget({
-    escapeHTML: escapeHTML
+    escapeHTML: escapeHTML,
+    transformItems: transformItems
   })), {}, {
     $$widgetType: 'ais.autocomplete'
   })]))];