@assistant-ui/ai-sdk 0.0.5 → 0.0.6

package/src/runtime/AISDKThreads.cloud.test.ts

@@ -54,23 +54,28 @@ const mocks = vi.hoisted(() => {
       return { history };
     },
   };
-  return { adapter };
+  return {
+    adapter,
+    useCloudThreadListAdapter: vi.fn(() => adapter),
+  };
 });
 
 vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/core/react")>()),
-  useCloudThreadListAdapter: () => mocks.adapter,
+  useCloudThreadListAdapter: mocks.useCloudThreadListAdapter,
 }));
 
 import { AISDKThreads } from "./AISDKThreads";
 import { createCancellableTransport } from "./__tests__/controlled-transport";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 describe("AISDKThreads cloud", () => {
   it("reloads history when switching a keyed cloud thread", async () => {
+    const cloud = {} as AssistantCloud;
     const handle = createAssistantClient(
       AuiConfig({
         threads: AISDKThreads({
-          cloud: {} as AssistantCloud,
+          cloud,
           threadId: "t1",
         }),
       }),
@@ -84,6 +89,10 @@ describe("AISDKThreads cloud", () => {
     await vi.waitFor(() => {
       expect(load).toHaveBeenCalled();
     });
+    expect(mocks.useCloudThreadListAdapter).toHaveBeenCalledWith({
+      cloud,
+      sdk: AI_SDK_SDK,
+    });
     const afterFirst = load.mock.calls.length;
     flushTapSync(() => aui.threads.switchToThread("t2"));
     await vi.waitFor(() => {

package/src/runtime/AISDKThreads.test.ts

@@ -251,17 +251,28 @@ describe("AISDKThreads", () => {
     }
   });
 
-  it("forwards ChatInit callbacks to each thread's chat", async () => {
+  it("forwards ChatInit callbacks to each thread's chat from the latest render", async () => {
     const { transport, emit, close } = createControlledTransport();
-    const onFinish = vi.fn();
-    const handle = createAssistantClient(
-      AuiConfig({
-        threads: AISDKThreads({ transport: () => transport, onFinish }),
-      }),
-    );
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
     handle.subscribe(() => {});
     const aui = handle.getClient();
 
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
     flushTapSync(() => aui.composer.setText("hi"));
     flushTapSync(() => aui.composer.send());
     await vi.waitFor(() => {
@@ -271,11 +282,123 @@ describe("AISDKThreads", () => {
     });
     emit(...textReply("done"));
     close();
-    await vi.waitFor(() => expect(onFinish).toHaveBeenCalledTimes(1));
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
 
     handle.destroy();
   });
 
+  it("forwards the latest callbacks to a switched-away thread still streaming in the background", async () => {
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+
+    flushTapSync(() => aui.composer.setText("stream me"));
+    flushTapSync(() => aui.composer.send());
+    await vi.waitFor(() => {
+      expect(
+        handle.getClient().thread.getState().messages.length,
+      ).toBeGreaterThan(0);
+    });
+    emit(
+      { type: "start" },
+      { type: "text-start", id: "t1" },
+      { type: "text-delta", id: "t1", delta: "partial" },
+    );
+
+    flushTapSync(() => aui.threads.switchToNewThread());
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
+    emit({ type: "text-end", id: "t1" }, { type: "finish" });
+    close();
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
+
+    handle.destroy();
+  });
+
+  it("forwards the latest callbacks to a cloud thread's chat", async () => {
+    const cloudThread = (id: string) => ({
+      id,
+      title: id,
+      is_archived: false,
+      last_message_at: null,
+      external_id: null,
+      metadata: null,
+    });
+    const cloud = {
+      threads: {
+        list: vi.fn(async () => ({ threads: [cloudThread("t1")] })),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        get: vi.fn(async (id: string) => cloudThread(id)),
+        messages: {
+          list: vi.fn(async () => ({ messages: [] })),
+          create: vi.fn(async () => ({ message_id: "remote-message-1" })),
+          update: vi.fn(),
+        },
+      },
+      runs: { stream: vi.fn(), report: vi.fn() },
+      telemetry: { enabled: false },
+    } as unknown as AssistantCloud;
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ cloud, threadId: "t1", transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    try {
+      await handle.getClient().threads.getLoadThreadsPromise();
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+      });
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isLoading).toBe(false);
+      });
+
+      onFinish = onFinishB;
+      flushTapSync(() => listeners.forEach((listener) => listener()));
+
+      flushTapSync(() => handle.getClient().composer.setText("hi"));
+      flushTapSync(() => handle.getClient().composer.send());
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isRunning).toBe(true);
+      });
+      emit(...textReply("done"));
+      close();
+      await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+      expect(onFinishA).not.toHaveBeenCalled();
+    } finally {
+      handle.destroy();
+    }
+  });
+
   it("posts each thread's own id as the chat id", async () => {
     const bodies: unknown[] = [];
     const fetchStub = vi.fn(async (_url: unknown, init?: RequestInit) => {

package/src/runtime/AISDKThreads.ts

@@ -26,6 +26,7 @@ import {
 } from "./useChatThread";
 import { MessageRepository } from "@assistant-ui/core/internal";
 import { useResourceCleanup } from "./useResourceCleanup";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 export type AISDKThreadsOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   Omit<ChatThreadOptions<UI_MESSAGE>, "id" | "transport" | "messages"> & {
@@ -62,16 +63,22 @@ type AISDKThreadChatOptions<UI_MESSAGE extends UIMessage = UIMessage> = Omit<
   "cloud" | "threadId" | "onThreadIdChange"
 >;
 
+type ChatOptionsRef<UI_MESSAGE extends UIMessage> = {
+  current: AISDKThreadChatOptions<UI_MESSAGE> | undefined;
+};
+
 type ChatEntry<UI_MESSAGE extends UIMessage> = {
   chat: Chat<UI_MESSAGE>;
   transport: ChatTransport<UI_MESSAGE>;
   repository: MessageRepository;
+  optionsRef: ChatOptionsRef<UI_MESSAGE>;
 };
 
 const createChatEntry = <UI_MESSAGE extends UIMessage>(
   threadId: string,
   options: AISDKThreadChatOptions<UI_MESSAGE> | undefined,
 ): ChatEntry<UI_MESSAGE> => {
+  const optionsRef: ChatOptionsRef<UI_MESSAGE> = { current: options };
   const { chatInit } = splitChatThreadOptions(
     options as ChatThreadOptions<UI_MESSAGE> | undefined,
   );
@@ -84,9 +91,20 @@ const createChatEntry = <UI_MESSAGE extends UIMessage>(
           ? options.transport.__internal_clone()
           : options.transport;
   return {
-    chat: new Chat<UI_MESSAGE>({ ...chatInit, id: threadId, transport }),
+    chat: new Chat<UI_MESSAGE>({
+      ...chatInit,
+      id: threadId,
+      transport,
+      onToolCall: (arg) => optionsRef.current?.onToolCall?.(arg),
+      onData: (arg) => optionsRef.current?.onData?.(arg),
+      onFinish: (arg) => optionsRef.current?.onFinish?.(arg),
+      onError: (arg) => optionsRef.current?.onError?.(arg),
+      sendAutomaticallyWhen: (arg) =>
+        optionsRef.current?.sendAutomaticallyWhen?.(arg) ?? false,
+    }),
     transport,
     repository: new MessageRepository(),
+    optionsRef,
   };
 };
 
@@ -116,9 +134,13 @@ const useAISDKChatThread = <UI_MESSAGE extends UIMessage = UIMessage>({
   const [owned] = useState(() =>
     cloud ? createChatEntry(threadId, options) : undefined,
   );
-  const { chat, transport, repository } =
+  const { chat, transport, repository, optionsRef } =
     owned ?? getOrCreateChatEntry(threadId, options, chats);
 
+  useEffect(() => {
+    if (cloud) optionsRef.current = options;
+  });
+
   useEffect(() => {
     if (!cloud) return undefined;
     return () => {
@@ -173,13 +195,19 @@ const useAISDKThreads = <UI_MESSAGE extends UIMessage = UIMessage>(
   const [chats] = useState(() => new Map<string, ChatEntry<UI_MESSAGE>>());
   const bindCloud = cloud !== undefined;
 
+  useEffect(() => {
+    for (const { optionsRef } of chats.values()) {
+      optionsRef.current = threadOptions;
+    }
+  });
+
   useResourceCleanup(true, () => {
     for (const { chat } of chats.values()) {
       void chat.stop().catch(() => {});
     }
   });
 
-  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   const thread = (id: string) => {
     const element = AISDKChatThread({
       threadId: id,

package/src/runtime/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const AI_SDK_SDK: SdkIdentity = {
+  name: "@assistant-ui/ai-sdk",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};

package/src/runtime/useAISDKRuntime.test.ts

@@ -77,7 +77,6 @@ const textOf = (message: any): string =>
 
 describe("useAISDKRuntime", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
     vi.mocked(useExternalHistory).mockReturnValue({
       isLoading: false,
       deleteMessage: vi.fn().mockResolvedValue(undefined),
@@ -1487,4 +1486,43 @@ describe("useAISDKRuntime", () => {
       error: chat.error,
     });
   });
+
+  it("keeps the error name and code on the failed message status", () => {
+    const chat = createChatHelpers([
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      { id: "a1", role: "assistant", parts: [{ type: "text", text: "" }] },
+    ]);
+    chat.error = Object.assign(new Error("rate limited"), {
+      name: "AI_APICallError",
+      code: "rate_limited",
+    });
+
+    const { result } = renderHook(() => useAISDKRuntime(chat));
+
+    expect(
+      result.current.thread.getState().messages.at(-1)?.status,
+    ).toMatchObject({
+      type: "incomplete",
+      reason: "error",
+      error: { code: "rate_limited", message: "rate limited" },
+    });
+  });
+
+  it("uses the error name as the code when the error carries none", () => {
+    const chat = createChatHelpers([
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      { id: "a1", role: "assistant", parts: [{ type: "text", text: "" }] },
+    ]);
+    chat.error = Object.assign(new Error("upstream failed"), {
+      name: "AI_APICallError",
+    });
+
+    const { result } = renderHook(() => useAISDKRuntime(chat));
+
+    expect(
+      result.current.thread.getState().messages.at(-1)?.status,
+    ).toMatchObject({
+      error: { code: "AI_APICallError", message: "upstream failed" },
+    });
+  });
 });

package/src/runtime/useAISDKRuntime.ts

@@ -47,6 +47,7 @@ import {
   MessageRepository,
 } from "@assistant-ui/core/internal";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
+import type { AssistantError } from "@assistant-ui/core";
 import { sliceMessagesUntil } from "../utils/sliceMessagesUntil";
 import { toCreateMessage } from "../converters/toCreateMessage";
 import { vercelAttachmentAdapter } from "../adapters/vercelAttachmentAdapter";
@@ -219,6 +220,19 @@ const useGeneratedSuggestions = (
 
 const NO_CANCELLED_MESSAGE_IDS: ReadonlySet<string> = new Set();
 
+const toChatError = (error: Error): AssistantError => {
+  const code = (error as { code?: unknown }).code;
+  return {
+    code:
+      typeof code === "string"
+        ? code
+        : error.name !== "Error"
+          ? error.name
+          : "unknown",
+    message: error.message,
+  };
+};
+
 export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>,
   adapter: AISDKRuntimeAdapter<UI_MESSAGE> = {},
@@ -315,7 +329,9 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         toolLastInputCache: toolLastInputCacheRef.current,
         mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
         ...(optimisticMessageId && { optimisticMessageId }),
-        ...(chatHelpers.error && { error: chatHelpers.error.message }),
+        ...(chatHelpers.error && {
+          error: toChatError(chatHelpers.error),
+        }),
         ...(cancelledMessageIds.size > 0 && { cancelledMessageIds }),
       }),
       [

package/src/runtime/useChatRuntime.test.ts

@@ -88,7 +88,6 @@ const sendMessagesOptions = {
 
 describe("useChatRuntime", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
     mocks.state.isLoadingHistory = false;
     mocks.state.threadId = "thread-id";
     mocks.state.mainThreadId = "thread-id";

package/src/runtime/useChatRuntime.ts

@@ -9,6 +9,7 @@ import {
 } from "@assistant-ui/core/react";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import { useChatThread, type ChatThreadOptions } from "./useChatThread";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   ChatThreadOptions<UI_MESSAGE> & {
@@ -38,7 +39,7 @@ export const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>({
   onThreadIdChange,
   ...options
 }: UseChatRuntimeOptions<UI_MESSAGE> = {}): AssistantRuntime => {
-  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
       return useChatThreadRuntime(options);

package/src/runtime/useChatThread.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from "vitest";
+import { resource, useResource, flushTapSync } from "@assistant-ui/tap";
+import { useState } from "react";
+import {
+  RuntimeAdapter,
+  runtimeAdapterTransformScopes,
+} from "@assistant-ui/core/store";
+import {
+  attachTransformScopes,
+  AuiConfig,
+  createAssistantClient,
+} from "@assistant-ui/store/client";
+import { useChatThread, type ChatThreadEnvironment } from "./useChatThread";
+import {
+  createCancellableTransport,
+  nextTask,
+} from "./__tests__/controlled-transport";
+
+const createHost = (
+  env: Pick<ChatThreadEnvironment, "stopOnClientDestroy">,
+) => {
+  const useHost = (options: Parameters<typeof useChatThread>[0]) => {
+    const [threadListItem] = useState(() => ({
+      initialize: async () => ({ remoteId: "main", externalId: undefined }),
+    }));
+    const runtime = useChatThread(options, {
+      id: "main",
+      isMainThread: true,
+      getThreadListItem: () => threadListItem,
+      ...env,
+    });
+    return useResource(RuntimeAdapter(runtime));
+  };
+  attachTransformScopes(useHost, runtimeAdapterTransformScopes);
+  return resource(useHost);
+};
+
+const streamThenDestroy = async (
+  env: Pick<ChatThreadEnvironment, "stopOnClientDestroy">,
+) => {
+  const { transport, getCancelCount, close } = createCancellableTransport();
+  const Host = createHost(env);
+  const handle = createAssistantClient(
+    AuiConfig({ threads: Host({ transport }) }),
+  );
+  handle.subscribe(() => {});
+  const aui = handle.getClient();
+
+  try {
+    flushTapSync(() => aui.composer.setText("stop me"));
+    flushTapSync(() => aui.composer.send());
+    await vi.waitFor(() => {
+      expect(aui.thread.getState().isRunning).toBe(true);
+    });
+  } finally {
+    handle.destroy();
+  }
+  await nextTask();
+  const cancelCount = getCancelCount();
+  if (cancelCount === 0) close();
+  return cancelCount;
+};
+
+describe("useChatThread", () => {
+  it("stops an in-flight chat on client destroy when stopOnClientDestroy is omitted", async () => {
+    expect(await streamThenDestroy({})).toBe(1);
+  });
+
+  it("leaves an in-flight chat running on client destroy when stopOnClientDestroy is false", async () => {
+    expect(await streamThenDestroy({ stopOnClientDestroy: false })).toBe(0);
+  });
+});

package/src/runtime/useChatThread.ts

@@ -188,7 +188,7 @@ export const useChatThread = <UI_MESSAGE extends UIMessage = UIMessage>(
     id,
     isMainThread,
     getThreadListItem,
-    stopOnClientDestroy = false,
+    stopOnClientDestroy = true,
     chat: externalChat,
     messageRepositoryInstance,
   } = env;

package/src/runtime/useExternalHistory.test.ts

@@ -780,6 +780,35 @@ describe("useExternalHistory persistence", () => {
       ],
       expect.any(Object),
     );
+    expect(reportTelemetry.mock.calls[0]![1]).toMatchObject({
+      message: expect.objectContaining({
+        id: "assistant-a",
+        status: { type: "complete", reason: "stop" },
+      }),
+    });
+  });
+
+  it("reports a run that failed before any assistant message", async () => {
+    const { append, reportTelemetry, runCycle, flush } =
+      createPersistenceHarness(true);
+    const failed = createAssistantMessage(
+      {
+        type: "incomplete",
+        reason: "error",
+        error: { code: "AI_APICallError", message: "upstream failed" },
+      },
+      [],
+    );
+
+    await runCycle([failed]);
+    await flush();
+
+    expect(append).not.toHaveBeenCalled();
+    expect(reportTelemetry).toHaveBeenCalledTimes(1);
+    expect(reportTelemetry).toHaveBeenCalledWith(
+      [],
+      expect.objectContaining({ message: failed }),
+    );
   });
 
   it("restores deferred telemetry for reloaded paused messages", async () => {

package/src/runtime/useExternalHistory.ts

@@ -371,7 +371,10 @@ export const useExternalHistory = <TMessage>(
 
             if (deferredTelemetryIds.current.has(message.id) && isTerminal) {
               deferredTelemetryIds.current.delete(message.id);
-              adapter.reportTelemetry?.(batchItems, telemetryOptions);
+              adapter.reportTelemetry?.(batchItems, {
+                ...telemetryOptions,
+                message,
+              });
             }
           }
         })

package/src/transport/AssistantChatTransport.test.ts

@@ -1,5 +1,5 @@
 import type { UIMessage } from "ai";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import { RESUMABLE_STREAM_ID_HEADER } from "./resumable";
 import { AssistantChatTransport } from "./AssistantChatTransport";
@@ -26,10 +26,6 @@ const sendMessagesOptions = {
 };
 
 describe("AssistantChatTransport.prepareSendMessagesRequest", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
   it("passes the initialized remote thread id to prepareSendMessagesRequest as options.id", async () => {
     const threadListItem = createThreadListItem("remote-thread-id");
     const captured: { id: unknown } = { id: undefined };
@@ -209,10 +205,6 @@ const wrappedFetchOf = (
   ).fetch;
 
 describe("AssistantChatTransport resumable fetch wrapper", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
   it("passes a 204 with a non-null empty body through untouched (WebKit)", async () => {
     const response = nullBodyStatusWithBody(204);
     const fetchMock = vi.fn(async () => response);

package/dist/adapters/aiSDKFormatAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aiSDKFormatAdapter.d.ts","names":[],"sources":["../../src/adapters/aiSDKFormatAdapter.ts"],"mappings":";;;KAQY,qBAAqB,KAAK;cAEzB,sBAAsB,qBACjC,WACA"}

package/dist/adapters/aiSDKFormatAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aiSDKFormatAdapter.js","names":["UIMessage","MessageFormatAdapter","MessageFormatItem","MessageStorageEntry","AISDKStorageFormat","Omit","aiSDKV6FormatAdapter","format","encode","message","id","parts","decode","stored","parentId","parent_id","content","getId"],"sources":["../../src/adapters/aiSDKFormatAdapter.ts"],"sourcesContent":["import type { UIMessage } from \"ai\";\nimport type {\n  MessageFormatAdapter,\n  MessageFormatItem,\n  MessageStorageEntry,\n} from \"@assistant-ui/core\";\n\n// Storage format for AI SDK messages - just the UIMessage\nexport type AISDKStorageFormat = Omit<UIMessage, \"id\">;\n\nexport const aiSDKV6FormatAdapter: MessageFormatAdapter<\n  UIMessage,\n  AISDKStorageFormat\n> = {\n  format: \"ai-sdk/v6\",\n\n  encode({\n    message: { id, parts, ...message },\n  }: MessageFormatItem<UIMessage>): AISDKStorageFormat {\n    return {\n      ...message,\n      parts,\n    };\n  },\n\n  decode(\n    stored: MessageStorageEntry<AISDKStorageFormat>,\n  ): MessageFormatItem<UIMessage> {\n    return {\n      parentId: stored.parent_id,\n      message: {\n        id: stored.id,\n        ...stored.content,\n      },\n    };\n  },\n\n  getId(message: UIMessage): string {\n    return message.id;\n  },\n};\n"],"mappings":";AAUA,MAAaM,uBAGT;CACFC,QAAQ;CAERC,OAAO,EACLC,SAAS,EAAEC,IAAIC,OAAO,GAAGF,aAC0B;EACnD,OAAO;GACL,GAAGA;GACHE;EACF;CACF;CAEAC,OACEC,QAC8B;EAC9B,OAAO;GACLC,UAAUD,OAAOE;GACjBN,SAAS;IACPC,IAAIG,OAAOH;IACX,GAAGG,OAAOG;GACZ;EACF;CACF;CAEAC,MAAMR,SAA4B;EAChC,OAAOA,QAAQC;CACjB;AACF"}