@kernl-sdk/ai 0.1.3 → 0.2.5

package/dist/convert/__tests__/ui-message.test.js

@@ -0,0 +1,1836 @@
+import { describe, it, expect } from "vitest";
+import { IN_PROGRESS, COMPLETED, FAILED } from "@kernl-sdk/protocol";
+import { UIMessageCodec, historyToUIMessages } from "../ui-message";
+describe("UIMessageCodec", () => {
+    // ----------------------------
+    // Text parts
+    // ----------------------------
+    describe("decode - text parts", () => {
+        it("should convert a user message with a text part", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [{ type: "text", text: "Hello, world!" }],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                id: "1",
+                role: "user",
+                content: [
+                    {
+                        kind: "text",
+                        text: "Hello, world!",
+                    },
+                ],
+            });
+        });
+        it("should convert an assistant message with a text part", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "2",
+                role: "assistant",
+                parts: [{ type: "text", text: "Hi there!" }],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                id: "2",
+                role: "assistant",
+                content: [
+                    {
+                        kind: "text",
+                        text: "Hi there!",
+                    },
+                ],
+            });
+        });
+        it("should convert a system message with a text part", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "3",
+                role: "system",
+                parts: [{ type: "text", text: "System prompt" }],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                id: "3",
+                role: "system",
+                content: [
+                    {
+                        kind: "text",
+                        text: "System prompt",
+                    },
+                ],
+            });
+        });
+        it("should preserve providerMetadata", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "4",
+                role: "user",
+                parts: [
+                    {
+                        type: "text",
+                        text: "Test",
+                        providerMetadata: { anthropic: { custom: "data" } },
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "text",
+                    text: "Test",
+                    providerMetadata: { anthropic: { custom: "data" } },
+                });
+            }
+        });
+    });
+    // ----------------------------
+    // File parts - Data URLs
+    // ----------------------------
+    describe("decode - file parts with Data URLs", () => {
+        it("should convert a file part with base64 Data URL", async () => {
+            const base64Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+            const dataUrl = `data:image/png;base64,${base64Data}`;
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "image/png",
+                        filename: "test.png",
+                        url: dataUrl,
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "image/png",
+                    filename: "test.png",
+                    data: base64Data,
+                });
+                expect(message.content[0]).not.toHaveProperty("uri");
+            }
+        });
+        it("should handle various image MIME types", async () => {
+            const mimeTypes = [
+                "image/png",
+                "image/jpeg",
+                "image/gif",
+                "image/webp",
+                "image/svg+xml",
+            ];
+            for (const mimeType of mimeTypes) {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "user",
+                    parts: [
+                        {
+                            type: "file",
+                            mediaType: mimeType,
+                            url: `data:${mimeType};base64,abc123`,
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                const message = result[0];
+                if (message.kind === "message") {
+                    expect(message.content[0]).toMatchObject({
+                        kind: "file",
+                        mimeType,
+                        data: "abc123",
+                    });
+                }
+            }
+        });
+        it("should handle PDF and document types", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "application/pdf",
+                        filename: "document.pdf",
+                        url: "data:application/pdf;base64,JVBERi0xLjQ=",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "application/pdf",
+                    filename: "document.pdf",
+                    data: "JVBERi0xLjQ=",
+                });
+            }
+        });
+    });
+    // ----------------------------
+    // File parts - Regular URLs
+    // ----------------------------
+    describe("decode - file parts with URLs", () => {
+        it("should convert a file part with http URL to uri field", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "image/png",
+                        filename: "photo.png",
+                        url: "http://example.com/photo.png",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "image/png",
+                    filename: "photo.png",
+                    uri: "http://example.com/photo.png",
+                });
+                expect(message.content[0]).not.toHaveProperty("data");
+            }
+        });
+        it("should convert a file part with https URL to uri field", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "application/pdf",
+                        url: "https://example.com/document.pdf",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "application/pdf",
+                    uri: "https://example.com/document.pdf",
+                });
+            }
+        });
+        it("should handle file URLs without filename", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "text/plain",
+                        url: "https://example.com/file",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "text/plain",
+                    uri: "https://example.com/file",
+                });
+                const filePart = message.content[0];
+                if (filePart.kind === "file") {
+                    expect(filePart.filename).toBeUndefined();
+                }
+            }
+        });
+        it("should convert non-base64 Data URL to uri field", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "text/plain",
+                        url: "data:text/plain,Hello%20World",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    mimeType: "text/plain",
+                    uri: "data:text/plain,Hello%20World",
+                });
+            }
+        });
+    });
+    // ----------------------------
+    // Multiple parts
+    // ----------------------------
+    describe("decode - multiple parts", () => {
+        it("should convert a message with multiple text parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    { type: "text", text: "First part" },
+                    { type: "text", text: "Second part" },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content).toHaveLength(2);
+                expect(message.content[0]).toMatchObject({
+                    kind: "text",
+                    text: "First part",
+                });
+                expect(message.content[1]).toMatchObject({
+                    kind: "text",
+                    text: "Second part",
+                });
+            }
+        });
+        it("should convert a message with mixed text and file parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    { type: "text", text: "Check this image:" },
+                    {
+                        type: "file",
+                        mediaType: "image/png",
+                        url: "data:image/png;base64,abc123",
+                    },
+                    { type: "text", text: "What do you see?" },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content).toHaveLength(3);
+                expect(message.content[0]).toMatchObject({
+                    kind: "text",
+                    text: "Check this image:",
+                });
+                expect(message.content[1]).toMatchObject({
+                    kind: "file",
+                    mimeType: "image/png",
+                    data: "abc123",
+                });
+                expect(message.content[2]).toMatchObject({
+                    kind: "text",
+                    text: "What do you see?",
+                });
+            }
+        });
+        it("should convert a message with multiple files", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [
+                    {
+                        type: "file",
+                        mediaType: "image/png",
+                        url: "data:image/png;base64,image1",
+                    },
+                    {
+                        type: "file",
+                        mediaType: "image/jpeg",
+                        url: "https://example.com/image2.jpg",
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.content).toHaveLength(2);
+                expect(message.content[0]).toMatchObject({
+                    kind: "file",
+                    data: "image1",
+                });
+                expect(message.content[1]).toMatchObject({
+                    kind: "file",
+                    uri: "https://example.com/image2.jpg",
+                });
+            }
+        });
+    });
+    // ----------------------------
+    // Tool parts
+    // ----------------------------
+    describe("decode - tool parts", () => {
+        describe("static tool invocations (tool-*)", () => {
+            it("should convert input-available state to ToolCall with IN_PROGRESS", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: { operation: "add", numbers: [1, 2] },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ operation: "add", numbers: [1, 2] }),
+                });
+            });
+            it("should convert output-available state to ToolResult with COMPLETED", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: { operation: "add", numbers: [1, 2] },
+                            output: { result: 3 },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: COMPLETED,
+                    result: { result: 3 },
+                    error: null,
+                });
+            });
+            it("should convert output-error state to ToolResult with FAILED", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "output-error",
+                            toolCallId: "call-1",
+                            input: { operation: "divide", numbers: [1, 0] },
+                            errorText: "Division by zero",
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: FAILED,
+                    result: null,
+                    error: "Division by zero",
+                });
+            });
+            it("should skip input-streaming state", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "input-streaming",
+                            toolCallId: "call-1",
+                            input: { operation: "add" },
+                        },
+                        { type: "text", text: "After streaming" },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "message",
+                    content: [{ kind: "text", text: "After streaming" }],
+                });
+            });
+            it("should preserve callProviderMetadata on tool calls", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-weather",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: { city: "Tokyo" },
+                            callProviderMetadata: {
+                                anthropic: { cacheControl: { type: "ephemeral" } },
+                            },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "weather",
+                    providerMetadata: {
+                        anthropic: { cacheControl: { type: "ephemeral" } },
+                    },
+                });
+            });
+            it("should preserve callProviderMetadata on tool results", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-weather",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: { city: "Tokyo" },
+                            output: { temperature: 20 },
+                            callProviderMetadata: {
+                                anthropic: { signature: "12345" },
+                            },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "weather",
+                    providerMetadata: {
+                        anthropic: { signature: "12345" },
+                    },
+                });
+            });
+        });
+        describe("dynamic tool invocations", () => {
+            it("should convert input-available state to ToolCall", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "dynamic-tool",
+                            toolName: "screenshot",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: { region: "full" },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "screenshot",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ region: "full" }),
+                });
+            });
+            it("should convert output-available state to ToolResult", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "dynamic-tool",
+                            toolName: "screenshot",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: { region: "full" },
+                            output: "base64imagedata",
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "screenshot",
+                    state: COMPLETED,
+                    result: "base64imagedata",
+                    error: null,
+                });
+            });
+            it("should convert output-error state to ToolResult", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "dynamic-tool",
+                            toolName: "screenshot",
+                            state: "output-error",
+                            toolCallId: "call-1",
+                            input: { region: "full" },
+                            errorText: "Screen capture failed",
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(1);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "screenshot",
+                    state: FAILED,
+                    result: null,
+                    error: "Screen capture failed",
+                });
+            });
+        });
+        describe("multiple tool invocations", () => {
+            it("should handle message with multiple tool calls", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Let me help with that" },
+                        {
+                            type: "tool-calculator",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: { operation: "add", numbers: [1, 2] },
+                        },
+                        {
+                            type: "tool-weather",
+                            state: "input-available",
+                            toolCallId: "call-2",
+                            input: { city: "Tokyo" },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(3);
+                expect(result[0]).toMatchObject({
+                    kind: "message",
+                    content: [{ kind: "text", text: "Let me help with that" }],
+                });
+                expect(result[1]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "calculator",
+                });
+                expect(result[2]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-2",
+                    toolId: "weather",
+                });
+            });
+            it("should handle message with mixed tool calls and results", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: { operation: "add", numbers: [1, 2] },
+                            output: { result: 3 },
+                        },
+                        { type: "text", text: "The result is 3" },
+                        {
+                            type: "tool-weather",
+                            state: "input-available",
+                            toolCallId: "call-2",
+                            input: { city: "Tokyo" },
+                        },
+                    ],
+                });
+                // Message with text parts comes first (via unshift), then tools in order
+                expect(result).toHaveLength(3);
+                expect(result[0]).toMatchObject({
+                    kind: "message",
+                    content: [{ kind: "text", text: "The result is 3" }],
+                });
+                expect(result[1]).toMatchObject({
+                    kind: "tool-result",
+                    callId: "call-1",
+                });
+                expect(result[2]).toMatchObject({
+                    kind: "tool-call",
+                    callId: "call-2",
+                });
+            });
+            it("should handle message with both static and dynamic tools", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: { operation: "add", numbers: [1, 2] },
+                        },
+                        {
+                            type: "dynamic-tool",
+                            toolName: "screenshot",
+                            state: "input-available",
+                            toolCallId: "call-2",
+                            input: { region: "full" },
+                        },
+                    ],
+                });
+                expect(result).toHaveLength(2);
+                expect(result[0]).toMatchObject({
+                    kind: "tool-call",
+                    toolId: "calculator",
+                });
+                expect(result[1]).toMatchObject({
+                    kind: "tool-call",
+                    toolId: "screenshot",
+                });
+            });
+        });
+        describe("tool output types", () => {
+            it("should handle string output", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: {},
+                            output: "result string",
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    result: "result string",
+                });
+            });
+            it("should handle number output", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-calculator",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: {},
+                            output: 42,
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    result: 42,
+                });
+            });
+            it("should handle object output", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-weather",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: {},
+                            output: {
+                                temperature: 20,
+                                condition: "sunny",
+                                humidity: 60,
+                            },
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    result: {
+                        temperature: 20,
+                        condition: "sunny",
+                        humidity: 60,
+                    },
+                });
+            });
+            it("should handle array output", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-search",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: {},
+                            output: ["result1", "result2", "result3"],
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    result: ["result1", "result2", "result3"],
+                });
+            });
+            it("should handle null output", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-test",
+                            state: "output-available",
+                            toolCallId: "call-1",
+                            input: {},
+                            output: null,
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-result",
+                    result: null,
+                });
+            });
+            it("should handle undefined output as empty object", async () => {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "tool-test",
+                            state: "input-available",
+                            toolCallId: "call-1",
+                            input: undefined,
+                        },
+                    ],
+                });
+                expect(result[0]).toMatchObject({
+                    kind: "tool-call",
+                    arguments: "{}",
+                });
+            });
+        });
+    });
+    // ----------------------------
+    // Reasoning parts
+    // ----------------------------
+    describe("decode - reasoning parts", () => {
+        it("should convert reasoning parts to separate reasoning items", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    { type: "text", text: "Before reasoning" },
+                    { type: "reasoning", text: "Let me think..." },
+                    { type: "text", text: "After reasoning" },
+                ],
+            });
+            expect(result).toHaveLength(2);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                content: [
+                    { kind: "text", text: "Before reasoning" },
+                    { kind: "text", text: "After reasoning" },
+                ],
+            });
+            expect(result[1]).toMatchObject({
+                kind: "reasoning",
+                text: "Let me think...",
+            });
+        });
+        it("should preserve providerMetadata on reasoning parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    {
+                        type: "reasoning",
+                        text: "Thinking...",
+                        providerMetadata: {
+                            anthropic: { signature: "12345" },
+                        },
+                    },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "reasoning",
+                text: "Thinking...",
+                providerMetadata: {
+                    anthropic: { signature: "12345" },
+                },
+            });
+        });
+        it("should handle multiple reasoning parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    { type: "reasoning", text: "First thought" },
+                    { type: "reasoning", text: "Second thought" },
+                    { type: "text", text: "Final answer" },
+                ],
+            });
+            // Message comes first (via unshift), then reasoning parts in order
+            expect(result).toHaveLength(3);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                content: [{ kind: "text", text: "Final answer" }],
+            });
+            expect(result[1]).toMatchObject({
+                kind: "reasoning",
+                text: "First thought",
+            });
+            expect(result[2]).toMatchObject({
+                kind: "reasoning",
+                text: "Second thought",
+            });
+        });
+    });
+    // ----------------------------
+    // Parts that should be skipped
+    // ----------------------------
+    describe("decode - parts to skip", () => {
+        it("should skip step-start parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [{ type: "step-start" }, { type: "text", text: "Step content" }],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                content: [{ kind: "text", text: "Step content" }],
+            });
+        });
+        it("should skip source-url parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    {
+                        type: "source-url",
+                        sourceId: "1",
+                        url: "https://example.com",
+                        title: "Example",
+                    },
+                    { type: "text", text: "Main content" },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                content: [{ kind: "text", text: "Main content" }],
+            });
+        });
+        it("should skip source-document parts", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    {
+                        type: "source-document",
+                        sourceId: "1",
+                        mediaType: "text/plain",
+                        title: "Doc",
+                        filename: "doc.txt",
+                    },
+                    { type: "text", text: "Main content" },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "message",
+                content: [{ kind: "text", text: "Main content" }],
+            });
+        });
+    });
+    // ----------------------------
+    // Metadata handling
+    // ----------------------------
+    describe("decode - metadata", () => {
+        it("should preserve message metadata", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                metadata: { userId: "123", timestamp: 1234567890 },
+                parts: [{ type: "text", text: "Hello" }],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.metadata).toEqual({
+                    userId: "123",
+                    timestamp: 1234567890,
+                });
+            }
+        });
+        it("should handle messages without metadata", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [{ type: "text", text: "Hello" }],
+            });
+            expect(result).toHaveLength(1);
+            const message = result[0];
+            if (message.kind === "message") {
+                expect(message.metadata).toBeUndefined();
+            }
+        });
+    });
+    // ----------------------------
+    // Edge cases
+    // ----------------------------
+    describe("decode - edge cases", () => {
+        it("should reject empty parts array via AI SDK validation", async () => {
+            await expect(UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [],
+            })).rejects.toThrow("Message must contain at least one part");
+        });
+        it("should handle parts that are all skipped", async () => {
+            const result = await UIMessageCodec.decode({
+                id: "1",
+                role: "assistant",
+                parts: [
+                    { type: "reasoning", text: "Thinking..." },
+                    { type: "step-start" },
+                ],
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                kind: "reasoning",
+                text: "Thinking...",
+            });
+        });
+        it("should reject unknown part type via AI SDK validation", async () => {
+            await expect(UIMessageCodec.decode({
+                id: "1",
+                role: "user",
+                parts: [{ type: "unknown-type" }],
+            })).rejects.toThrow("Type validation failed");
+        });
+    });
+    // ----------------------------
+    // Validation tests
+    // ----------------------------
+    describe("decode - validation via AI SDK", () => {
+        it("should validate and reject invalid role", async () => {
+            await expect(UIMessageCodec.decode({
+                id: "1",
+                role: "invalid",
+                parts: [{ type: "text", text: "Hello" }],
+            })).rejects.toThrow();
+        });
+        it("should validate and accept all valid roles", async () => {
+            const roles = [
+                "system",
+                "user",
+                "assistant",
+            ];
+            for (const role of roles) {
+                const result = await UIMessageCodec.decode({
+                    id: "1",
+                    role,
+                    parts: [{ type: "text", text: "Hello" }],
+                });
+                expect(result).toHaveLength(1);
+                const message = result[0];
+                if (message.kind === "message") {
+                    expect(message.role).toBe(role);
+                }
+            }
+        });
+    });
+});
+describe("historyToUIMessages", () => {
+    describe("basic message conversion", () => {
+        it("should convert a simple user message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [{ kind: "text", text: "Hello, AI!" }],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [{ type: "text", text: "Hello, AI!" }],
+                },
+            ]);
+        });
+        it("should convert a simple assistant message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-2",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Hello, human!" }],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-2",
+                    role: "assistant",
+                    parts: [{ type: "text", text: "Hello, human!" }],
+                },
+            ]);
+        });
+        it("should convert a system message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-3",
+                    role: "system",
+                    content: [{ kind: "text", text: "System instructions" }],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-3",
+                    role: "system",
+                    parts: [{ type: "text", text: "System instructions" }],
+                },
+            ]);
+        });
+        it("should handle multiple messages", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [{ kind: "text", text: "What's the weather?" }],
+                },
+                {
+                    kind: "message",
+                    id: "msg-2",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "I'll check that for you." }],
+                },
+                {
+                    kind: "message",
+                    id: "msg-3",
+                    role: "user",
+                    content: [{ kind: "text", text: "Thanks!" }],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [{ type: "text", text: "What's the weather?" }],
+                },
+                {
+                    id: "msg-2",
+                    role: "assistant",
+                    parts: [{ type: "text", text: "I'll check that for you." }],
+                },
+                {
+                    id: "msg-3",
+                    role: "user",
+                    parts: [{ type: "text", text: "Thanks!" }],
+                },
+            ]);
+        });
+    });
+    describe("file parts", () => {
+        it("should convert file with base64 data URL", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [
+                        {
+                            kind: "file",
+                            mimeType: "image/jpeg",
+                            filename: "test.jpg",
+                            data: "dGVzdA==",
+                        },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [
+                        {
+                            type: "file",
+                            url: "data:image/jpeg;base64,dGVzdA==",
+                            mediaType: "image/jpeg",
+                            filename: "test.jpg",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should convert file with URI", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [
+                        {
+                            kind: "file",
+                            mimeType: "image/png",
+                            filename: "photo.png",
+                            uri: "https://example.com/photo.png",
+                        },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [
+                        {
+                            type: "file",
+                            url: "https://example.com/photo.png",
+                            mediaType: "image/png",
+                            filename: "photo.png",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should handle mixed text and file content", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [
+                        {
+                            kind: "file",
+                            mimeType: "image/jpeg",
+                            filename: "image.jpg",
+                            uri: "https://example.com/image.jpg",
+                        },
+                        { kind: "text", text: "Check this image" },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [
+                        {
+                            type: "file",
+                            url: "https://example.com/image.jpg",
+                            mediaType: "image/jpeg",
+                            filename: "image.jpg",
+                        },
+                        { type: "text", text: "Check this image" },
+                    ],
+                },
+            ]);
+        });
+    });
+    describe("data parts", () => {
+        it("should convert data parts", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [
+                        {
+                            kind: "data",
+                            data: { temperature: 72, humidity: 60 },
+                        },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "data-temperature", data: 72 },
+                        { type: "data-humidity", data: 60 },
+                    ],
+                },
+            ]);
+        });
+        it("should handle mixed data and text parts", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [
+                        { kind: "text", text: "Here's the data:" },
+                        {
+                            kind: "data",
+                            data: { count: 5 },
+                        },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Here's the data:" },
+                        { type: "data-count", data: 5 },
+                    ],
+                },
+            ]);
+        });
+    });
+    describe("tool calls and results", () => {
+        it("should convert tool call with successful result", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Let me calculate that." }],
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ operation: "add", numbers: [1, 2] }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: COMPLETED,
+                    result: 3,
+                    error: null,
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Let me calculate that." },
+                        {
+                            type: "tool-calculator",
+                            toolCallId: "call-1",
+                            toolName: "calculator",
+                            input: { operation: "add", numbers: [1, 2] },
+                            state: "output-available",
+                            output: 3,
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should convert tool call with error result", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Let me try that." }],
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ operation: "divide", numbers: [1, 0] }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: FAILED,
+                    result: null,
+                    error: "Division by zero",
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Let me try that." },
+                        {
+                            type: "tool-calculator",
+                            toolCallId: "call-1",
+                            toolName: "calculator",
+                            input: { operation: "divide", numbers: [1, 0] },
+                            state: "output-error",
+                            errorText: "Division by zero",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should convert tool call without result (pending)", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Processing..." }],
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "search",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ query: "weather" }),
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Processing..." },
+                        {
+                            type: "tool-search",
+                            toolCallId: "call-1",
+                            toolName: "search",
+                            input: { query: "weather" },
+                            state: "input-available",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should handle multiple tool calls with results", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "I'll use multiple tools." }],
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "tool1",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ value: "value-1" }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "tool1",
+                    state: COMPLETED,
+                    result: "result-1",
+                    error: null,
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-2",
+                    toolId: "tool2",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ value: "value-2" }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-2",
+                    toolId: "tool2",
+                    state: COMPLETED,
+                    result: "result-2",
+                    error: null,
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-3",
+                    toolId: "tool3",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ value: "value-3" }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-3",
+                    toolId: "tool3",
+                    state: COMPLETED,
+                    result: "result-3",
+                    error: null,
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "I'll use multiple tools." },
+                        {
+                            type: "tool-tool1",
+                            toolCallId: "call-1",
+                            toolName: "tool1",
+                            input: { value: "value-1" },
+                            state: "output-available",
+                            output: "result-1",
+                        },
+                        {
+                            type: "tool-tool2",
+                            toolCallId: "call-2",
+                            toolName: "tool2",
+                            input: { value: "value-2" },
+                            state: "output-available",
+                            output: "result-2",
+                        },
+                        {
+                            type: "tool-tool3",
+                            toolCallId: "call-3",
+                            toolName: "tool3",
+                            input: { value: "value-3" },
+                            state: "output-available",
+                            output: "result-3",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should skip orphaned tool results (result without call)", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Response" }],
+                },
+                {
+                    kind: "tool-result",
+                    callId: "orphan-1",
+                    toolId: "calculator",
+                    state: COMPLETED,
+                    result: 42,
+                    error: null,
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [{ type: "text", text: "Response" }],
+                },
+            ]);
+        });
+        it("should handle tool calls followed by next message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Using tool" }],
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "search",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ query: "test" }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "search",
+                    state: COMPLETED,
+                    result: "found it",
+                    error: null,
+                },
+                {
+                    kind: "message",
+                    id: "msg-2",
+                    role: "user",
+                    content: [{ kind: "text", text: "Thanks!" }],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Using tool" },
+                        {
+                            type: "tool-search",
+                            toolCallId: "call-1",
+                            toolName: "search",
+                            input: { query: "test" },
+                            state: "output-available",
+                            output: "found it",
+                        },
+                    ],
+                },
+                {
+                    id: "msg-2",
+                    role: "user",
+                    parts: [{ type: "text", text: "Thanks!" }],
+                },
+            ]);
+        });
+    });
+    describe("reasoning parts", () => {
+        it("should attach reasoning to last assistant message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Let me think..." }],
+                },
+                {
+                    kind: "reasoning",
+                    text: "Analyzing the problem step by step",
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Let me think..." },
+                        {
+                            type: "reasoning",
+                            text: "Analyzing the problem step by step",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should create new message for standalone reasoning", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [{ kind: "text", text: "Solve this problem" }],
+                },
+                {
+                    kind: "reasoning",
+                    id: "reasoning-1",
+                    text: "First, I need to understand the problem",
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [{ type: "text", text: "Solve this problem" }],
+                },
+                {
+                    id: "reasoning-1",
+                    role: "assistant",
+                    parts: [
+                        {
+                            type: "reasoning",
+                            text: "First, I need to understand the problem",
+                        },
+                    ],
+                },
+            ]);
+        });
+        it("should generate id for reasoning without id", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [{ kind: "text", text: "Question" }],
+                },
+                {
+                    kind: "reasoning",
+                    text: "Thinking...",
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [{ type: "text", text: "Question" }],
+                },
+                {
+                    id: "reasoning-1",
+                    role: "assistant",
+                    parts: [{ type: "reasoning", text: "Thinking..." }],
+                },
+            ]);
+        });
+        it("should attach multiple reasoning parts to assistant message", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "Response" }],
+                },
+                {
+                    kind: "reasoning",
+                    text: "Step 1: analyze",
+                },
+                {
+                    kind: "reasoning",
+                    text: "Step 2: synthesize",
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "Response" },
+                        { type: "reasoning", text: "Step 1: analyze" },
+                        { type: "reasoning", text: "Step 2: synthesize" },
+                    ],
+                },
+            ]);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle empty history", () => {
+            const items = [];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([]);
+        });
+        it("should handle message with empty content", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [],
+                },
+            ]);
+        });
+        it("should handle complex conversation with mixed content", () => {
+            const items = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [
+                        { kind: "text", text: "Check this image and calculate" },
+                        {
+                            kind: "file",
+                            mimeType: "image/png",
+                            filename: "chart.png",
+                            uri: "https://example.com/chart.png",
+                        },
+                    ],
+                },
+                {
+                    kind: "message",
+                    id: "msg-2",
+                    role: "assistant",
+                    content: [{ kind: "text", text: "I'll analyze the image" }],
+                },
+                {
+                    kind: "reasoning",
+                    text: "The image shows numerical data",
+                },
+                {
+                    kind: "tool-call",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: IN_PROGRESS,
+                    arguments: JSON.stringify({ operation: "sum", values: [10, 20, 30] }),
+                },
+                {
+                    kind: "tool-result",
+                    callId: "call-1",
+                    toolId: "calculator",
+                    state: COMPLETED,
+                    result: 60,
+                    error: null,
+                },
+                {
+                    kind: "message",
+                    id: "msg-3",
+                    role: "assistant",
+                    content: [
+                        { kind: "text", text: "The sum is" },
+                        { kind: "data", data: { total: 60 } },
+                    ],
+                },
+            ];
+            const result = historyToUIMessages(items);
+            expect(result).toEqual([
+                {
+                    id: "msg-1",
+                    role: "user",
+                    parts: [
+                        { type: "text", text: "Check this image and calculate" },
+                        {
+                            type: "file",
+                            url: "https://example.com/chart.png",
+                            mediaType: "image/png",
+                            filename: "chart.png",
+                        },
+                    ],
+                },
+                {
+                    id: "msg-2",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "I'll analyze the image" },
+                        {
+                            type: "reasoning",
+                            text: "The image shows numerical data",
+                        },
+                        {
+                            type: "tool-calculator",
+                            toolCallId: "call-1",
+                            toolName: "calculator",
+                            input: { operation: "sum", values: [10, 20, 30] },
+                            state: "output-available",
+                            output: 60,
+                        },
+                    ],
+                },
+                {
+                    id: "msg-3",
+                    role: "assistant",
+                    parts: [
+                        { type: "text", text: "The sum is" },
+                        { type: "data-total", data: 60 },
+                    ],
+                },
+            ]);
+        });
+    });
+});