@assistant-ui/core 0.2.23 → 0.3.1

package/src/react/primitive-hooks/useEditComposerSend.ts

@@ -6,7 +6,7 @@ export const useEditComposerSend = () => {
   const disabled = useAuiState((s) => s.composer.isEmpty);
 
   const send = useCallback(() => {
-    aui.composer().send();
+    aui.composer.send();
   }, [aui]);
 
   return { send, disabled };

package/src/react/primitive-hooks/useMessageBranching.ts

@@ -7,11 +7,11 @@ export const useMessageBranching = () => {
   const branchCount = useAuiState((s) => s.message.branchCount);
 
   const goToPrev = useCallback(() => {
-    aui.message().switchToBranch({ position: "previous" });
+    aui.message.switchToBranch({ position: "previous" });
   }, [aui]);
 
   const goToNext = useCallback(() => {
-    aui.message().switchToBranch({ position: "next" });
+    aui.message.switchToBranch({ position: "next" });
   }, [aui]);
 
   return { branchNumber, branchCount, goToPrev, goToNext };

package/src/react/primitive-hooks/useMessageReload.ts

@@ -6,7 +6,7 @@ export const useMessageReload = () => {
   const canReload = useAuiState((s) => s.message.role === "assistant");
 
   const reload = useCallback(() => {
-    aui.message().reload();
+    aui.message.reload();
   }, [aui]);
 
   return { reload, canReload };

package/src/react/primitive-hooks/useSuggestionTrigger.ts

@@ -17,24 +17,24 @@ export const useSuggestionTrigger = ({
   const resolvedSend = send ?? false;
 
   const trigger = useCallback(() => {
-    const isRunning = aui.thread().getState().isRunning;
+    const isRunning = aui.thread.getState().isRunning;
 
     if (resolvedSend && !isRunning) {
-      aui.thread().append({
+      aui.thread.append({
         content: [{ type: "text", text: prompt }],
-        runConfig: aui.composer().getState().runConfig,
+        runConfig: aui.composer.getState().runConfig,
       });
       if (clearComposer) {
-        aui.composer().setText("");
+        aui.composer.setText("");
       }
     } else {
       if (clearComposer) {
-        aui.composer().setText(prompt);
+        aui.composer.setText(prompt);
       } else {
-        const currentText = aui.composer().getState().text;
-        aui
-          .composer()
-          .setText(currentText.trim() ? `${currentText} ${prompt}` : prompt);
+        const currentText = aui.composer.getState().text;
+        aui.composer.setText(
+          currentText.trim() ? `${currentText} ${prompt}` : prompt,
+        );
       }
     }
   }, [aui, resolvedSend, clearComposer, prompt]);

package/src/react/primitive-hooks/useThreadListItemArchive.ts

@@ -5,7 +5,7 @@ export const useThreadListItemArchive = () => {
   const aui = useAui();
 
   const archive = useCallback(() => {
-    aui.threadListItem().archive();
+    aui.threadListItem.archive();
   }, [aui]);
 
   return { archive };

package/src/react/primitive-hooks/useThreadListItemDelete.ts

@@ -5,7 +5,7 @@ export const useThreadListItemDelete = () => {
   const aui = useAui();
 
   const deleteThread = useCallback(() => {
-    aui.threadListItem().delete();
+    aui.threadListItem.delete();
   }, [aui]);
 
   return { delete: deleteThread };

package/src/react/primitive-hooks/useThreadListItemTrigger.ts

@@ -5,7 +5,7 @@ export const useThreadListItemTrigger = () => {
   const aui = useAui();
 
   const switchTo = useCallback(() => {
-    aui.threadListItem().switchTo();
+    aui.threadListItem.switchTo();
   }, [aui]);
 
   return { switchTo };

package/src/react/primitive-hooks/useThreadListItemUnarchive.ts

@@ -5,7 +5,7 @@ export const useThreadListItemUnarchive = () => {
   const aui = useAui();
 
   const unarchive = useCallback(() => {
-    aui.threadListItem().unarchive();
+    aui.threadListItem.unarchive();
   }, [aui]);
 
   return { unarchive };

package/src/react/primitive-hooks/useThreadListLoadMore.ts

@@ -8,7 +8,7 @@ export const useThreadListLoadMore = () => {
   );
 
   const loadMore = useCallback(() => {
-    aui.threads().loadMore();
+    aui.threads.loadMore();
   }, [aui]);
 
   return { loadMore, disabled };

package/src/react/primitive-hooks/useThreadListNew.ts

@@ -5,7 +5,7 @@ export const useThreadListNew = () => {
   const aui = useAui();
 
   const switchToNewThread = useCallback(() => {
-    aui.threads().switchToNewThread();
+    aui.threads.switchToNewThread();
   }, [aui]);
 
   return { switchToNewThread };

package/src/react/primitive-hooks/useVoice.ts

@@ -10,7 +10,7 @@ const getServerVolume = () => 0;
 
 export const useVoiceVolume = (): number => {
   const aui = useAui();
-  const thread = aui.thread();
+  const thread = aui.thread;
   return useSyncExternalStore(
     thread.subscribeVoiceVolume,
     thread.getVoiceVolume,
@@ -22,19 +22,19 @@ export const useVoiceControls = () => {
   const aui = useAui();
 
   const connect = useCallback(() => {
-    aui.thread().connectVoice();
+    aui.thread.connectVoice();
   }, [aui]);
 
   const disconnect = useCallback(() => {
-    aui.thread().disconnectVoice();
+    aui.thread.disconnectVoice();
   }, [aui]);
 
   const mute = useCallback(() => {
-    aui.thread().muteVoice();
+    aui.thread.muteVoice();
   }, [aui]);
 
   const unmute = useCallback(() => {
-    aui.thread().unmuteVoice();
+    aui.thread.unmuteVoice();
   }, [aui]);
 
   return { connect, disconnect, mute, unmute };

package/src/react/primitives/chainOfThought/ChainOfThoughtParts.tsx

@@ -51,7 +51,7 @@ const ChainOfThoughtPrimitivePartsInner: FC<{
       Array.from({ length: partsLength }, (_, index) => (
         <ChainOfThoughtPartByIndexProvider key={index} index={index}>
           <RenderChildrenWithAccessor
-            getItemState={(aui) => aui.part().getState()}
+            getItemState={(aui) => aui.part.getState()}
           >
             {(getItem) =>
               children({

package/src/react/primitives/composer/ComposerAttachments.tsx

@@ -99,7 +99,7 @@ const ComposerPrimitiveAttachmentsInner: FC<{
         <ComposerAttachmentByIndexProvider key={index} index={index}>
           <RenderChildrenWithAccessor
             getItemState={(aui) =>
-              aui.composer().attachment({ index }).getState()
+              aui.composer.attachment({ index }).getState()
             }
           >
             {(getItem) =>

package/src/react/primitives/composer/ComposerQueue.tsx

@@ -20,9 +20,7 @@ const ComposerPrimitiveQueueInner: FC<{
       Array.from({ length: queue }, (_, index) => (
         <QueueItemByIndexProvider key={index} index={index}>
           <RenderChildrenWithAccessor
-            getItemState={(aui) =>
-              aui.composer().queueItem({ index }).getState()
-            }
+            getItemState={(aui) => aui.composer.queueItem({ index }).getState()}
           >
             {(getItem) =>
               children({

package/src/react/primitives/message/MessageAttachments.tsx

@@ -101,9 +101,7 @@ const MessagePrimitiveAttachmentsInner: FC<{
       Array.from({ length: attachmentsCount }, (_, index) => (
         <MessageAttachmentByIndexProvider key={index} index={index}>
           <RenderChildrenWithAccessor
-            getItemState={(aui) =>
-              aui.message().attachment({ index }).getState()
-            }
+            getItemState={(aui) => aui.message.attachment({ index }).getState()}
           >
             {(getItem) =>
               children({

package/src/react/primitives/message/MessageParts.tsx

@@ -415,9 +415,9 @@ export const MessagePartComponent: FC<MessagePartComponentProps> = ({
 
   const type = part.type;
   if (type === "tool-call") {
-    const addResult = aui.part().addToolResult;
-    const resume = aui.part().resumeToolCall;
-    const respondToApproval = aui.part().respondToToolApproval;
+    const addResult = aui.part.addToolResult;
+    const resume = aui.part.resumeToolCall;
+    const respondToApproval = aui.part.respondToToolApproval;
     if ("Override" in tools)
       return (
         <tools.Override
@@ -636,9 +636,9 @@ const RegisteredToolUI: FC = () => {
   return (
     <Render
       {...part}
-      addResult={aui.part().addToolResult}
-      resume={aui.part().resumeToolCall}
-      respondToApproval={aui.part().respondToToolApproval}
+      addResult={aui.part.addToolResult}
+      resume={aui.part.resumeToolCall}
+      respondToApproval={aui.part.respondToToolApproval}
     />
   );
 };
@@ -743,16 +743,16 @@ const MessagePartChildrenInner: FC<
 
   return (
     <RenderChildrenWithAccessor
-      getItemState={(client) => client.part().getState()}
+      getItemState={(client) => client.part.getState()}
     >
       {(getItem) =>
         children({
           get part() {
             const state = getItem();
             if (state.type === "tool-call") {
-              const toolsState = aui.tools().getState();
+              const toolsState = aui.tools.getState();
               const hasUI = resolveToolRender(toolsState, state) !== null;
-              const partMethods = aui.part();
+              const partMethods = aui.part;
               return {
                 ...state,
                 toolUI: hasUI ? <RegisteredToolUI /> : null,

package/src/react/primitives/thread/ThreadMessages.tsx

@@ -247,7 +247,7 @@ const ThreadPrimitiveMessagesInner: FC<{
     return Array.from({ length: messagesLength }, (_, index) => (
       <MessageByIndexProvider key={index} index={index}>
         <RenderChildrenWithAccessor
-          getItemState={(aui) => aui.thread().message({ index }).getState()}
+          getItemState={(aui) => aui.thread.message({ index }).getState()}
         >
           {(getItem) =>
             children({

package/src/react/primitives/thread/ThreadSuggestions.tsx

@@ -77,7 +77,7 @@ const ThreadPrimitiveSuggestionsInner: FC<{
       <SuggestionByIndexProvider key={index} index={index}>
         <RenderChildrenWithAccessor
           getItemState={(aui) =>
-            aui.suggestions().suggestion({ index }).getState()
+            aui.suggestions.suggestion({ index }).getState()
           }
         >
           {(getItem) =>

package/src/react/primitives/threadList/ThreadListItems.tsx

@@ -78,7 +78,7 @@ const ThreadListPrimitiveItemsInner: FC<{
         >
           <RenderChildrenWithAccessor
             getItemState={(aui) =>
-              aui.threads().item({ index, archived }).getState()
+              aui.threads.item({ index, archived }).getState()
             }
           >
             {(getItem) =>

package/src/react/providers/AttachmentByIndexProvider.tsx

@@ -10,7 +10,7 @@ export const MessageAttachmentByIndexProvider: FC<
     attachment: Derived({
       source: "message",
       query: { type: "index", index },
-      get: (aui) => aui.message().attachment({ index }),
+      get: (aui) => aui.message.attachment({ index }),
     }),
   });
 
@@ -26,7 +26,7 @@ export const ComposerAttachmentByIndexProvider: FC<
     attachment: Derived({
       source: "composer",
       query: { type: "index", index },
-      get: (aui) => aui.composer().attachment({ index }),
+      get: (aui) => aui.composer.attachment({ index }),
     }),
   });
 

package/src/react/providers/ChainOfThoughtByIndicesProvider.tsx

@@ -25,7 +25,7 @@ export const ChainOfThoughtByIndicesProvider: FC<
             `ChainOfThought part index ${index} is out of bounds (0..${parts.length - 1})`,
           );
         }
-        return parentAui.message().part({ index: startIndex + index });
+        return parentAui.message.part({ index: startIndex + index });
       },
     }),
   });

package/src/react/providers/ChainOfThoughtPartByIndexProvider.tsx

@@ -1,33 +1,16 @@
-import { useMemo, type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-import type { PartMethods } from "../../store/scopes/part";
 
 export const ChainOfThoughtPartByIndexProvider: FC<
   PropsWithChildren<{
     index: number;
   }>
 > = ({ index, children }) => {
-  const lastPartRef = useMemo(
-    () => ({ index, current: null as PartMethods | null }),
-    [index],
-  );
   const aui = useAui({
     part: Derived({
       source: "chainOfThought",
       query: { type: "index", index },
-      get: (aui) => {
-        const chainOfThought = aui.chainOfThought();
-        if (
-          index >= chainOfThought.getState().parts.length &&
-          lastPartRef.current
-        ) {
-          return lastPartRef.current;
-        }
-
-        const part = chainOfThought.part({ index });
-        lastPartRef.current = part;
-        return part;
-      },
+      get: (aui) => aui.chainOfThought.part({ index }),
     }),
   });
 

package/src/react/providers/MessageByIdProvider.tsx

@@ -10,12 +10,12 @@ export const MessageByIdProvider: FC<
     message: Derived({
       source: "thread",
       query: { type: "id", id },
-      get: (aui) => aui.thread().message({ id }),
+      get: (aui) => aui.thread.message({ id }),
     }),
     composer: Derived({
       source: "message",
       query: {},
-      get: (aui) => aui.thread().message({ id }).composer(),
+      get: (aui) => aui.thread.message({ id }).composer(),
     }),
   });
 

package/src/react/providers/MessageByIndexProvider.tsx

@@ -10,12 +10,12 @@ export const MessageByIndexProvider: FC<
     message: Derived({
       source: "thread",
       query: { type: "index", index },
-      get: (aui) => aui.thread().message({ index }),
+      get: (aui) => aui.thread.message({ index }),
     }),
     composer: Derived({
       source: "message",
       query: {},
-      get: (aui) => aui.thread().message({ index }).composer(),
+      get: (aui) => aui.thread.message({ index }).composer(),
     }),
   });
 

package/src/react/providers/PartByIndexProvider.tsx

@@ -1,30 +1,16 @@
-import { useMemo, type FC, type PropsWithChildren } from "react";
+import type { FC, PropsWithChildren } from "react";
 import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-import type { PartMethods } from "../../store/scopes/part";
 
 export const PartByIndexProvider: FC<
   PropsWithChildren<{
     index: number;
   }>
 > = ({ index, children }) => {
-  const lastPartRef = useMemo(
-    () => ({ index, current: null as PartMethods | null }),
-    [index],
-  );
   const aui = useAui({
     part: Derived({
       source: "message",
       query: { type: "index", index },
-      get: (aui) => {
-        const message = aui.message();
-        if (index >= message.getState().parts.length && lastPartRef.current) {
-          return lastPartRef.current;
-        }
-
-        const part = message.part({ index });
-        lastPartRef.current = part;
-        return part;
-      },
+      get: (aui) => aui.message.part({ index }),
     }),
   });
 

package/src/react/providers/QueueItemByIndexProvider.tsx

@@ -13,7 +13,7 @@ export const QueueItemByIndexProvider: FC<QueueItemByIndexProviderProps> = ({
     queueItem: Derived({
       source: "composer",
       query: { index },
-      get: (aui) => aui.composer().queueItem({ index }),
+      get: (aui) => aui.composer.queueItem({ index }),
     }),
   });
 

package/src/react/providers/ReadonlyThreadProvider.tsx

@@ -76,7 +76,7 @@ export const ReadonlyThreadProvider: FC<ReadonlyThreadProvider.Props> = ({
     composer: Derived({
       source: "thread",
       query: {},
-      get: (aui) => aui.thread().composer(),
+      get: (aui) => aui.thread.composer(),
     }),
   });
 

package/src/react/providers/SuggestionByIndexProvider.tsx

@@ -13,7 +13,7 @@ export const SuggestionByIndexProvider: FC<SuggestionByIndexProviderProps> = ({
     suggestion: Derived({
       source: "suggestions",
       query: { index },
-      get: (aui) => aui.suggestions().suggestion({ index }),
+      get: (aui) => aui.suggestions.suggestion({ index }),
     }),
   });
 

package/src/react/providers/ThreadListItemByIndexProvider.tsx

@@ -11,7 +11,7 @@ export const ThreadListItemByIndexProvider: FC<
     threadListItem: Derived({
       source: "threads",
       query: { type: "index", index, archived },
-      get: (aui) => aui.threads().item({ index, archived }),
+      get: (aui) => aui.threads.item({ index, archived }),
     }),
   });
 

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -147,15 +147,15 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       return runtime.threads.main.unstable_on("initialize", () => {
         if (hasInitializedRef.current) return;
 
-        const state = aui.threadListItem().getState();
+        const state = aui.threadListItem.getState();
         if (state.status !== "new") return;
         hasInitializedRef.current = true;
 
-        initPromiseRef.current = aui.threadListItem().initialize();
+        initPromiseRef.current = aui.threadListItem.initialize();
 
         const dispose = runtime.thread.unstable_on("runEnd", () => {
           dispose();
-          aui.threadListItem().generateTitle();
+          aui.threadListItem.generateTitle();
         });
       });
     }, [runtime, aui]);

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.test.tsx

@@ -6,20 +6,22 @@ import { describe, expect, it, vi } from "vitest";
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 
 const mocks = vi.hoisted(() => {
-  const threadListItem = {
-    getState: () => ({ remoteId: "thread-1" }),
-  };
+  const makeClient = (remoteId: string) =>
+    ({
+      threadListItem: {
+        getState: () => ({ remoteId }),
+      },
+    }) as unknown as import("@assistant-ui/store").AssistantClient;
 
   return {
-    assistantClient: {
-      threadListItem: () => threadListItem,
-    },
+    makeClient,
+    aui: makeClient("thread-1"),
   };
 });
 
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
-  useAui: () => mocks.assistantClient,
+  useAui: () => mocks.aui,
 }));
 
 const makeCloud = () =>
@@ -33,6 +35,7 @@ const makeCloud = () =>
 
 describe("useAssistantCloudThreadHistoryAdapter", () => {
   it("refreshes formatted persistence when the Cloud client changes", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
     const firstCloud = makeCloud();
     const secondCloud = makeCloud();
     const cloudRef = { current: firstCloud };
@@ -66,4 +69,26 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
       format: "test",
     });
   });
+
+  it("resolves the aui client at call time instead of capturing it", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const cloudRef = { current: cloud };
+    const { result, rerender } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+
+    await result.current.load();
+    expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
+      format: "aui/v0",
+    });
+
+    mocks.aui = mocks.makeClient("thread-2");
+    rerender();
+
+    await result.current.load();
+    expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-2", {
+      format: "aui/v0",
+    });
+  });
 });

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -1,4 +1,4 @@
-import { type RefObject, useState } from "react";
+import { type RefObject, useEffect, useRef, useState } from "react";
 import type {
   GenericThreadHistoryAdapter,
   ThreadHistoryAdapter,
@@ -13,25 +13,31 @@ import {
   createFormattedPersistence,
 } from "assistant-cloud";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
-import { type AssistantClient, useAui } from "@assistant-ui/store";
-import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
+import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
 
 const globalPersistence = new WeakMap<
-  ThreadListItemMethods,
+  getClientId.ClientId,
   CloudMessagePersistence
 >();
 
 class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   private cloudRef: RefObject<AssistantCloud>;
-  private aui: AssistantClient;
+  private auiRef: RefObject<AssistantClient>;
 
-  constructor(cloudRef: RefObject<AssistantCloud>, aui: AssistantClient) {
+  constructor(
+    cloudRef: RefObject<AssistantCloud>,
+    auiRef: RefObject<AssistantClient>,
+  ) {
     this.cloudRef = cloudRef;
-    this.aui = aui;
+    this.auiRef = auiRef;
+  }
+
+  private get aui(): AssistantClient {
+    return this.auiRef.current;
   }
 
   private get _persistence(): CloudMessagePersistence {
-    const key = this.aui.threadListItem();
+    const key = getClientId(this.aui.threadListItem);
     if (!globalPersistence.has(key)) {
       globalPersistence.set(
         key,
@@ -52,11 +58,11 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return {
       // Note: callers must also call reportTelemetry() for run tracking
       async append(item: MessageFormatItem<TMessage>) {
-        const { remoteId } = await adapter.aui.threadListItem().initialize();
+        const { remoteId } = await adapter.aui.threadListItem.initialize();
         await formatted.append(remoteId, item);
       },
       async update(item: MessageFormatItem<TMessage>, localMessageId: string) {
-        const remoteId = adapter.aui.threadListItem().getState().remoteId;
+        const remoteId = adapter.aui.threadListItem.getState().remoteId;
         if (!remoteId) return;
         await formatted.update?.(remoteId, item, localMessageId);
       },
@@ -82,7 +88,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         );
       },
       async load(): Promise<MessageFormatRepository<TMessage>> {
-        const remoteId = adapter.aui.threadListItem().getState().remoteId;
+        const remoteId = adapter.aui.threadListItem.getState().remoteId;
         if (!remoteId) return { messages: [] };
         return formatted.load(remoteId);
       },
@@ -90,7 +96,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 
   async append({ parentId, message }: ExportedMessageRepositoryItem) {
-    const { remoteId } = await this.aui.threadListItem().initialize();
+    const { remoteId } = await this.aui.threadListItem.initialize();
     const encoded = auiV0Encode(message);
     await this._persistence.append(
       remoteId,
@@ -110,7 +116,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
       return this.append(item);
     }
     const { message } = item;
-    const remoteId = this.aui.threadListItem().getState().remoteId;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return;
     const encoded = auiV0Encode(message);
     await this._persistence.update(remoteId, message.id, "aui/v0", encoded);
@@ -127,7 +133,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 
   async load() {
-    const remoteId = this.aui.threadListItem().getState().remoteId;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return { messages: [] };
     const messages = await this._persistence.load(remoteId, "aui/v0");
     return {
@@ -150,7 +156,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   ) {
     if (!this.cloudRef.current.telemetry.enabled) return;
 
-    const remoteId = this.aui.threadListItem().getState().remoteId;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return;
 
     const extracted = extractRunTelemetry(format, runMessages);
@@ -810,8 +816,12 @@ export function useAssistantCloudThreadHistoryAdapter(
   cloudRef: RefObject<AssistantCloud>,
 ): ThreadHistoryAdapter {
   const aui = useAui();
+  const auiRef = useRef(aui);
+  useEffect(() => {
+    auiRef.current = aui;
+  });
   const [adapter] = useState(
-    () => new AssistantCloudThreadHistoryAdapter(cloudRef, aui),
+    () => new AssistantCloudThreadHistoryAdapter(cloudRef, auiRef),
   );
   return adapter;
 }