@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/dist/utils/getVercelAIMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVercelAIMessages.d.ts","mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,oBAAoB;AAC3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI;AAEnC,eAAO,MAAM,mBAAmB,GAAI,UAAU,SAAS,SAAS,GAAG,SAAS,EAC1E,SAAS,aAAa,KAEsB,UAAU,EACvD","names":[],"ignoreList":[],"sources":["../../src/utils/getVercelAIMessages.ts"],"sourcesContent":[null]}

package/dist/utils/getVercelAIMessages.js

@@ -0,0 +1,8 @@
+import { getExternalStoreMessages } from "@ulearning/ai-core";
+// src/utils/getVercelAIMessages.ts
+const getVercelAIMessages = (message) => {
+	return getExternalStoreMessages(message);
+};
+export { getVercelAIMessages };
+
+//# sourceMappingURL=getVercelAIMessages.js.map

package/dist/utils/getVercelAIMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVercelAIMessages.js","names":[],"sources":["../../src/utils/getVercelAIMessages.ts"],"sourcesContent":["import {\n  getExternalStoreMessages,\n  type ThreadMessage,\n} from \"@ulearning/ai-core\";\nimport type { UIMessage } from \"ai\";\n\nexport const getVercelAIMessages = <UI_MESSAGE extends UIMessage = UIMessage>(\n  message: ThreadMessage,\n) => {\n  return getExternalStoreMessages(message) as UI_MESSAGE[];\n};\n"],"mappings":";;AAMA,MAAa,uBACX,YACG;CACH,OAAO,yBAAyB,OAAO;AACzC"}

package/dist/utils/sliceMessagesUntil.d.ts

@@ -0,0 +1,3 @@
+import type { UIMessage } from "ai";
+export declare const sliceMessagesUntil: <UI_MESSAGE extends UIMessage = UIMessage>(messages: UI_MESSAGE[], messageId: string | null) => UI_MESSAGE[];
+//# sourceMappingURL=sliceMessagesUntil.d.ts.map

package/dist/utils/sliceMessagesUntil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceMessagesUntil.d.ts","mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI;AAEnC,eAAO,MAAM,kBAAkB,GAAI,UAAU,SAAS,SAAS,GAAG,SAAS,EACzE,UAAU,UAAU,EAAE,EACtB,WAAW,MAAM,GAAG,IAAI,iBAWzB","names":[],"ignoreList":[],"sources":["../../src/utils/sliceMessagesUntil.ts"],"sourcesContent":[null]}

package/dist/utils/sliceMessagesUntil.js

@@ -0,0 +1,10 @@
+// src/utils/sliceMessagesUntil.ts
+const sliceMessagesUntil = (messages, messageId) => {
+	if (messageId == null) return [];
+	const messageIdx = messages.findIndex((m) => m.id === messageId);
+	if (messageIdx === -1) throw new Error(`sliceMessagesUntil: Message "${messageId}" not found in AI SDK messages. This is likely an internal bug in assistant-ui.`);
+	return messages.slice(0, messageIdx + 1);
+};
+export { sliceMessagesUntil };
+
+//# sourceMappingURL=sliceMessagesUntil.js.map

package/dist/utils/sliceMessagesUntil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sliceMessagesUntil.js","names":[],"sources":["../../src/utils/sliceMessagesUntil.ts"],"sourcesContent":["import type { UIMessage } from \"ai\";\n\nexport const sliceMessagesUntil = <UI_MESSAGE extends UIMessage = UIMessage>(\n  messages: UI_MESSAGE[],\n  messageId: string | null,\n) => {\n  if (messageId == null) return [];\n\n  const messageIdx = messages.findIndex((m) => m.id === messageId);\n  if (messageIdx === -1)\n    throw new Error(\n      `sliceMessagesUntil: Message \"${messageId}\" not found in AI SDK messages. This is likely an internal bug in assistant-ui.`,\n    );\n\n  return messages.slice(0, messageIdx + 1);\n};\n"],"mappings":";AAEA,MAAa,sBACX,UACA,cACG;CACH,IAAI,aAAa,MAAM,OAAO,CAAC;CAE/B,MAAM,aAAa,SAAS,WAAW,MAAM,EAAE,OAAO,SAAS;CAC/D,IAAI,eAAe,IACjB,MAAM,IAAI,MACR,gCAAgC,UAAU,gFAC5C;CAEF,OAAO,SAAS,MAAM,GAAG,aAAa,CAAC;AACzC"}

package/package.json

@@ -1,6 +1,99 @@
 {
   "name": "@ulearning/ai-sdk-adapter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-next.0",
+  "description": "Vercel AI SDK adapter for assistant-ui",
+  "keywords": [
+    "ai-sdk",
+    "vercel",
+    "assistant-ui",
+    "vue",
+    "ai",
+    "chat",
+    "openai",
+    "streaming"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "imports": {
+    "#mcp-stdio": {
+      "types": "./src/tools/mcp-stdio.node.ts",
+      "react-native": "./dist/tools/mcp-stdio.unsupported.js",
+      "edge-light": "./dist/tools/mcp-stdio.unsupported.js",
+      "workerd": "./dist/tools/mcp-stdio.unsupported.js",
+      "browser": "./dist/tools/mcp-stdio.unsupported.js",
+      "node": "./dist/tools/mcp-stdio.node.js",
+      "default": "./dist/tools/mcp-stdio.unsupported.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@ai-sdk/mcp": "2.0.90",
+    "@ulearning/ai-core": "^1.0.0-next.0",
+    "@ulearning/ai-store": "^1.0.0-next.0",
+    "@ulearning/ai-tap": "^1.0.0-next.0",
+    "@ulearning/ai-stream": "^0.3.56-next.0",
+    "@ai-sdk/vue": "4.0.162"
+  },
+  "peerDependencies": {
+    "ai": "^7.0.162",
+    "vue": "^3.5.22"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ulearning/ai-buildutils": "0.0.33-next.0",
+    "@ulearning/ai-vue-compat": "0.0.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/react": "^19.3.0",
+    "ai": "7.0.162",
+    "jsdom": "^30.1.3",
+    "react": "^19.3.1",
+    "vitest": "^5.0.5",
+    "vue": "3.5.44",
+    "vue-tsc": "3.3.14",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "@testing-library/dom": "^10.4.2",
+    "@ai-sdk/react": "^4.0.157"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": false
+  },
+  "homepage": "http://1.92.106.239/frontend-common/ai-sdk",
+  "repository": {
+    "type": "git",
+    "url": "http://1.92.106.239/frontend-common/ai-sdk.git",
+    "directory": "packages/ai-sdk"
+  },
+  "bugs": {
+    "url": "http://1.92.106.239/frontend-common/ai-sdk/-/issues"
+  },
+  "scripts": {
+    "build": "aui-build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage --coverage.reporter=text --coverage.reporter=html --coverage.reporter=json-summary",
+    "typecheck": "vue-tsc --noEmit && vue-tsc --noEmit -p tsconfig.test.json",
+    "test:peer-vue": "vitest run --config vitest.peer-vue.config.ts",
+    "test:artifacts": "vitest run --config vitest.artifacts.config.ts",
+    "test:standalone": "vitest run --project standalone",
+    "test:watch": "vitest",
+    "test:types:peer-vue": "aui-vue-compat-types"
+  }
 }

package/src/__tests__/standalone.e2e.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  flushTapSync,
+  useEffect,
+  useState,
+  useTapRoot,
+} from "@ulearning/ai-tap";
+import { effectScope } from "vue";
+import { AuiConfig, createAssistantClient } from "@ulearning/ai-store/client";
+import * as aiSdk from "../index";
+import { createControlledTransport } from "../runtime/__tests__/controlled-transport";
+
+vi.mock("react", () => {
+  throw new Error("The native standalone graph must not import React.");
+});
+vi.mock("react-dom", () => {
+  throw new Error("The native standalone graph must not import React DOM.");
+});
+vi.mock("react/jsx-runtime", () => {
+  throw new Error("The native standalone graph must not import React JSX.");
+});
+vi.mock("react/jsx-dev-runtime", () => {
+  throw new Error(
+    "The native standalone graph must not import React development JSX.",
+  );
+});
+vi.mock("react-dom/client", () => {
+  throw new Error(
+    "The native standalone graph must not import the React DOM client.",
+  );
+});
+vi.mock("react-dom/server", () => {
+  throw new Error(
+    "The native standalone graph must not import the React DOM server.",
+  );
+});
+
+describe("native Vue standalone graph", () => {
+  it("owns a real Vue scope and releases its standalone Tap resource exactly once", () => {
+    const scope = effectScope();
+    const setup = vi.fn();
+    const cleanup = vi.fn();
+    const root = scope.run(() =>
+      useTapRoot(function useNativeStandaloneCounter() {
+        const [count, setCount] = useState(0);
+        useEffect(() => {
+          setup();
+          return cleanup;
+        }, []);
+        return { count, setCount };
+      }),
+    )!;
+    const values: number[] = [];
+    const unsubscribe = root.subscribe(() =>
+      values.push(root.getValue().count),
+    );
+    try {
+      expect(root.getValue().count).toBe(0);
+      expect(setup).toHaveBeenCalledTimes(1);
+      flushTapSync(() => root.getValue().setCount(2));
+      expect(root.getValue().count).toBe(2);
+      expect(values).toEqual([2]);
+      scope.stop();
+      scope.stop();
+      expect(cleanup).toHaveBeenCalledTimes(1);
+    } finally {
+      unsubscribe();
+      scope.stop();
+    }
+  });
+
+  it("loads the whole native barrel without importing React", () => {
+    expect(typeof aiSdk.AISDKChat).toBe("function");
+    expect(typeof aiSdk.useChatRuntime).toBe("function");
+    expect(typeof aiSdk.useAISDKRuntime).toBe("function");
+    expect(typeof aiSdk.frontendTools).toBe("function");
+    expect(typeof aiSdk.AssistantChatTransport).toBe("function");
+  });
+
+  it("streams a native standalone chat round trip", async () => {
+    const { transport, emit, close } = createControlledTransport();
+    const handle = createAssistantClient(
+      AuiConfig({ threads: aiSdk.AISDKChat({ transport }) }),
+    );
+    try {
+      handle.subscribe(() => {});
+      const aui = handle.getClient();
+
+      flushTapSync(() => aui.composer.setText("hi"));
+      flushTapSync(() => aui.composer.send());
+
+      await vi.waitFor(() => {
+        expect(aui.thread.getState().isRunning).toBe(true);
+      });
+
+      emit(
+        { type: "start" },
+        { type: "text-start", id: "t1" },
+        { type: "text-delta", id: "t1", delta: "hello " },
+        { type: "text-delta", id: "t1", delta: "world" },
+        { type: "text-end", id: "t1" },
+        { type: "finish" },
+      );
+      close();
+
+      await vi.waitFor(() => {
+        const state = aui.thread.getState();
+        expect(state.isRunning).toBe(false);
+        expect(state.messages).toHaveLength(2);
+        expect(state.messages.at(-1)?.content).toContainEqual(
+          expect.objectContaining({ type: "text", text: "hello world" }),
+        );
+      });
+    } finally {
+      handle.destroy();
+    }
+  });
+});

package/src/adapters/aiSDKFormatAdapter.test.ts

@@ -0,0 +1,36 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { aiSDKV6FormatAdapter } from "./aiSDKFormatAdapter";
+
+const assistant = (
+  parts: UIMessage["parts"],
+  metadata?: Record<string, unknown>,
+  id = "a1",
+): UIMessage =>
+  ({
+    id,
+    role: "assistant",
+    parts,
+    ...(metadata ? { metadata } : {}),
+  }) as UIMessage;
+
+describe("aiSDKV6FormatAdapter", () => {
+  it("stores a message without its id and restores it from the row", () => {
+    const message = assistant([{ type: "text", text: "hi" }], { a: 1 });
+    const content = aiSDKV6FormatAdapter.encode({ parentId: null, message });
+    expect(content).toEqual({
+      role: "assistant",
+      parts: [{ type: "text", text: "hi" }],
+      metadata: { a: 1 },
+    });
+    expect(
+      aiSDKV6FormatAdapter.decode({
+        id: "a1",
+        parent_id: "u1",
+        format: "ai-sdk/v6",
+        content,
+      }),
+    ).toEqual({ parentId: "u1", message });
+    expect(aiSDKV6FormatAdapter.getId(message)).toBe("a1");
+  });
+});

package/src/adapters/aiSDKFormatAdapter.ts

@@ -0,0 +1,18 @@
+import type { UIMessage } from "ai";
+import type { MessageFormatAdapter } from "@ulearning/ai-core";
+
+export type AISDKStorageFormat = Omit<UIMessage, "id">;
+
+/** The stored form of an AI SDK message: the message without its id. */
+export const aiSDKV6FormatAdapter: MessageFormatAdapter<
+  UIMessage,
+  AISDKStorageFormat
+> = {
+  format: "ai-sdk/v6",
+  encode: ({ message: { id: _id, ...message } }) => message,
+  decode: (stored) => ({
+    parentId: stored.parent_id,
+    message: { id: stored.id, ...stored.content } as UIMessage,
+  }),
+  getId: (message) => message.id,
+};

package/src/adapters/vercelAttachmentAdapter.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { vercelAttachmentAdapter } from "./vercelAttachmentAdapter";
+
+const originalFileReader = globalThis.FileReader;
+
+afterEach(() => {
+  globalThis.FileReader = originalFileReader;
+});
+
+describe("vercelAttachmentAdapter", () => {
+  it("sends a file as a data URL via the shared core encoder", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+
+    const file = new File(["hello"], "a.txt", { type: "text/plain" });
+    const result = await vercelAttachmentAdapter.send({
+      id: "1",
+      type: "file",
+      name: file.name,
+      file,
+      contentType: file.type,
+      content: [],
+      status: { type: "requires-action", reason: "composer-send" },
+    });
+
+    const part = result.content[0];
+    if (part?.type !== "file") throw new Error("expected file content part");
+    expect(part.data).toBe("data:text/plain;base64,aGVsbG8=");
+  });
+
+  it("aborts a file send via the shared core encoder", async () => {
+    globalThis.FileReader = undefined as unknown as typeof FileReader;
+
+    const file = new File(["hello"], "a.txt", { type: "text/plain" });
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      vercelAttachmentAdapter.send(
+        {
+          id: "1",
+          type: "file",
+          name: file.name,
+          file,
+          contentType: file.type,
+          content: [],
+          status: { type: "requires-action", reason: "composer-send" },
+        },
+        { signal: controller.signal },
+      ),
+    ).rejects.toBe(controller.signal.reason);
+  });
+});

package/src/adapters/vercelAttachmentAdapter.ts

@@ -0,0 +1,36 @@
+import type { AttachmentAdapter } from "@ulearning/ai-core";
+import { getFileDataURL } from "@ulearning/ai-core/internal";
+import { generateId } from "ai";
+
+export const vercelAttachmentAdapter: AttachmentAdapter = {
+  accept: "*",
+  async add({ file }) {
+    return {
+      id: generateId(),
+      type: file.type.startsWith("image/") ? "image" : "file",
+      name: file.name,
+      file,
+      contentType: file.type,
+      content: [],
+      status: { type: "requires-action", reason: "composer-send" },
+    };
+  },
+  async send(attachment, options) {
+    // noop
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content: [
+        {
+          type: "file",
+          mimeType: attachment.contentType ?? "",
+          filename: attachment.name,
+          data: await getFileDataURL(attachment.file, options),
+        },
+      ],
+    };
+  },
+  async remove() {
+    // noop
+  },
+};

package/src/aiSDKExtras.ts

@@ -0,0 +1,31 @@
+import { createRuntimeExtras } from "@ulearning/ai-core/vue";
+import type { AbstractChat, UIMessage } from "ai";
+
+/** Framework independent advanced chat surface, preserving the AI SDK 7 methods. */
+export type AISDKChatHelpers<UI_MESSAGE extends UIMessage = UIMessage> = {
+  readonly id: string;
+  setMessages: (
+    messages: UI_MESSAGE[] | ((messages: UI_MESSAGE[]) => UI_MESSAGE[]),
+  ) => void;
+  error: Error | undefined;
+} & Pick<
+  AbstractChat<UI_MESSAGE>,
+  | "sendMessage"
+  | "regenerate"
+  | "stop"
+  | "resumeStream"
+  | "addToolResult"
+  | "addToolOutput"
+  | "addToolApprovalResponse"
+  | "status"
+  | "messages"
+  | "clearError"
+>;
+
+export type AISDKRuntimeExtras = {
+  chat: AISDKChatHelpers<UIMessage>;
+  error: Error | undefined;
+};
+
+export const aiSDKExtras =
+  createRuntimeExtras<AISDKRuntimeExtras>("useAISDKRuntime");

package/src/converters/convertMessage.metadata-key.test.tsx

@@ -0,0 +1,182 @@
+// @vitest-environment jsdom
+
+import { defineComponent, h, shallowRef } from "vue";
+import { render } from "../runtime/__tests__/vue";
+import type { UIMessage } from "ai";
+import type { Unstable_ToolInteractionLog } from "@ulearning/ai-core";
+import { useExternalMessageConverter } from "@ulearning/ai-core/vue";
+import { describe, expect, it, vi } from "vitest";
+import {
+  AISDKMessageConverter,
+  convertAISDKMessage,
+  createAISDKMetadataKey,
+  type AISDKMessageConverterMetadata,
+} from "./convertMessage";
+
+const messages: UIMessage[] = [
+  { id: "u0", role: "user", parts: [{ type: "text", text: "weather?" }] },
+  {
+    id: "a1",
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-weather",
+        toolCallId: "call-1",
+        state: "output-available",
+        input: { city: "NYC" },
+        output: { temp: 72 },
+      },
+    ],
+  },
+  { id: "u2", role: "user", parts: [{ type: "text", text: "and Paris?" }] },
+  {
+    id: "a3",
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-weather",
+        toolCallId: "call-3",
+        state: "input-available",
+        input: { city: "Paris" },
+      },
+    ],
+  },
+  { id: "u4", role: "user", parts: [{ type: "text", text: "deploy" }] },
+  {
+    id: "a5",
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-deploy",
+        toolCallId: "call-5",
+        state: "approval-requested",
+        input: { target: "prod" },
+        approval: { id: "approval-5" },
+      },
+    ],
+  },
+  { id: "u6", role: "user", parts: [{ type: "text", text: "thanks" }] },
+  { id: "a7", role: "assistant", parts: [{ type: "text", text: "done" }] },
+];
+const ALL_IDS = messages.map((message) => message.id);
+
+// Keyed by every metadata field, so adding one fails typecheck until its
+// invalidation is pinned here.
+const fieldChanges: {
+  [K in keyof Required<AISDKMessageConverterMetadata>]: [
+    value: AISDKMessageConverterMetadata[K],
+    reconverts: readonly string[],
+  ];
+} = {
+  toolStatuses: [
+    {
+      "call-3": {
+        type: "interrupt",
+        payload: { type: "human", payload: { question: "unit?" } },
+      },
+    },
+    ["a3"],
+  ],
+  toolArtifacts: [new Map([["call-3", { chart: true }]]), ["a3"]],
+  toolInteractions: [
+    new Map([
+      [
+        "call-3",
+        {
+          entries: [{ type: "progress", payload: { step: 1 }, timestamp: 1 }],
+        } as unknown as Unstable_ToolInteractionLog,
+      ],
+    ]),
+    ["a3"],
+  ],
+  toolApprovalResponses: [
+    new Map([["approval-5", { approvalId: "approval-5", approved: true }]]),
+    ["a5"],
+  ],
+  cancelledToolApprovalIds: [new Set(["approval-5"]), ["a5"]],
+  cancelledStatusMessageIds: [new Set(["a3"]), ["a3"]],
+  messageTiming: [
+    {
+      a7: {
+        streamStartTime: 1,
+        totalStreamTime: 5,
+        totalChunks: 3,
+        toolCallCount: 1,
+      },
+    },
+    ["a7"],
+  ],
+  optimisticMessageId: ["a7", ["a7"]],
+  supportsRichToolApprovalResponses: [true, ["a5"]],
+  createdAtCache: [new Map(), ALL_IDS],
+  toolLastInputCache: [new Map(), ALL_IDS],
+  toolArgsKeyOrderCache: [new Map(), ALL_IDS],
+  toolArgsTextCache: [new WeakMap(), ALL_IDS],
+  mcpAppMetadataCache: [new Map(), ALL_IDS],
+  // Core applies these after the callback, so no message re-converts.
+  error: ["boom", []],
+  cancelledMessageIds: [new Set(["a7"]), []],
+};
+
+const scenarios: {
+  name: string;
+  patch: Partial<AISDKMessageConverterMetadata>;
+  reconverts: readonly string[];
+}[] = [
+  ...Object.entries(fieldChanges).map(([name, [value, reconverts]]) => ({
+    name,
+    patch: { [name]: value },
+    reconverts,
+  })),
+  {
+    name: "an unrelated tool status",
+    patch: { toolStatuses: { "call-unknown": { type: "executing" } } },
+    reconverts: [],
+  },
+];
+
+describe("createAISDKMetadataKey", () => {
+  it.each(scenarios)(
+    "re-converts only the affected messages when $name changes and reverts",
+    ({ patch, reconverts }) => {
+      const callback = vi.fn(convertAISDKMessage);
+      const getMetadataKey = createAISDKMetadataKey();
+      // A shared createdAt cache keeps the uncached comparison's dates equal.
+      const base: AISDKMessageConverterMetadata = { createdAtCache: new Map() };
+      const metadataSource = shallowRef(base);
+      let converted!: ReturnType<typeof useExternalMessageConverter<UIMessage>>;
+      const view = render(
+        h(
+          defineComponent({
+            setup() {
+              converted = useExternalMessageConverter(() => ({
+                callback,
+                messages,
+                isRunning: false,
+                metadata: metadataSource.value,
+                getMetadataKey,
+              }));
+              return () => null;
+            },
+          }),
+        ),
+      );
+      void converted.value;
+      expect(callback).toHaveBeenCalledTimes(messages.length);
+
+      for (const metadata of [{ ...base, ...patch }, { ...base }]) {
+        callback.mockClear();
+        metadataSource.value = metadata;
+        const result = converted.value;
+
+        expect(callback.mock.calls.map(([message]) => message.id)).toEqual(
+          reconverts,
+        );
+        expect([...result]).toEqual(
+          AISDKMessageConverter.toThreadMessages(messages, false, metadata),
+        );
+      }
+      view.unmount();
+    },
+  );
+});