assistant-stream 0.2.46 → 0.3.0

package/src/core/converters/toGenericMessages.test.ts

@@ -0,0 +1,721 @@
+import { describe, expect, it } from "vitest";
+import { toGenericMessages } from "./toGenericMessages";
+
+describe("toGenericMessages", () => {
+  describe("system messages", () => {
+    it("converts text content", () => {
+      const result = toGenericMessages([
+        {
+          role: "system",
+          content: [{ type: "text", text: "You are a helpful assistant." }],
+        },
+      ]);
+
+      expect(result).toEqual([
+        { role: "system", content: "You are a helpful assistant." },
+      ]);
+    });
+
+    it("handles empty text", () => {
+      const result = toGenericMessages([
+        {
+          role: "system",
+          content: [{ type: "text", text: "" }],
+        },
+      ]);
+
+      expect(result).toEqual([]);
+    });
+
+    it("handles missing text property", () => {
+      const result = toGenericMessages([
+        {
+          role: "system",
+          content: [{ type: "text" }],
+        },
+      ]);
+
+      expect(result).toEqual([]);
+    });
+
+    it("uses first text part when multiple exist", () => {
+      const result = toGenericMessages([
+        {
+          role: "system",
+          content: [
+            { type: "text", text: "First" },
+            { type: "text", text: "Second" },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([{ role: "system", content: "First" }]);
+    });
+  });
+
+  describe("user messages", () => {
+    it("converts text parts", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "text", text: "Hello!" }],
+        },
+      ]);
+
+      expect(result).toEqual([
+        { role: "user", content: [{ type: "text", text: "Hello!" }] },
+      ]);
+    });
+
+    it("converts image parts with media type inference", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "image", image: "https://example.com/photo.jpg" }],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              data: new URL("https://example.com/photo.jpg"),
+              mediaType: "image/jpeg",
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("converts file parts", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              data: "https://example.com/doc.pdf",
+              mimeType: "application/pdf",
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              data: new URL("https://example.com/doc.pdf"),
+              mediaType: "application/pdf",
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("handles attachments", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "text", text: "See attached" }],
+          attachments: [
+            {
+              content: [
+                {
+                  type: "file",
+                  data: "https://example.com/file.txt",
+                  mimeType: "text/plain",
+                },
+              ],
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "user",
+          content: [
+            { type: "text", text: "See attached" },
+            {
+              type: "file",
+              data: new URL("https://example.com/file.txt"),
+              mediaType: "text/plain",
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("filters invalid parts", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [
+            { type: "text", text: "Valid" },
+            { type: "image" }, // missing image property
+            { type: "file", data: "some-data" }, // missing mimeType
+            { type: "unknown" },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        { role: "user", content: [{ type: "text", text: "Valid" }] },
+      ]);
+    });
+
+    it("handles data URL as URL object", () => {
+      const dataUrl =
+        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "image", image: dataUrl }],
+        },
+      ]);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("user");
+      const content = (result[0] as { content: unknown[] }).content;
+      expect(content[0]).toMatchObject({
+        type: "file",
+        mediaType: "image/png",
+      });
+      expect((content[0] as { data: unknown }).data).toBeInstanceOf(URL);
+    });
+
+    it("handles relative/invalid URL as string", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              data: "/relative/path/file.txt",
+              mimeType: "text/plain",
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "user",
+          content: [
+            {
+              type: "file",
+              data: "/relative/path/file.txt",
+              mediaType: "text/plain",
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("produces empty result when all parts are invalid", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "unknown" }],
+        },
+      ]);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("assistant messages", () => {
+    it("converts text parts", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "Hello!" }],
+        },
+      ]);
+
+      expect(result).toEqual([
+        { role: "assistant", content: [{ type: "text", text: "Hello!" }] },
+      ]);
+    });
+
+    it("converts tool calls without results", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("converts tool calls with results (creates tool message)", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+              result: { temperature: 20, unit: "celsius" },
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+        {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              result: { temperature: 20, unit: "celsius" },
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("includes isError in tool result when present", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+              result: "Error: City not found",
+              isError: true,
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+        {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: "call_123",
+              toolName: "get_weather",
+              result: "Error: City not found",
+              isError: true,
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("handles text-tool interleaving (flush on text boundary)", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "Let me check the weather." },
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "get_weather",
+              args: { city: "London" },
+              result: { temp: 20 },
+            },
+            { type: "text", text: "The weather is nice." },
+          ],
+        },
+      ]);
+
+      // The flush happens BEFORE adding text when there are pending tool results
+      // So first assistant message contains both initial text and tool call
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "Let me check the weather." },
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+        {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: "call_1",
+              toolName: "get_weather",
+              result: { temp: 20 },
+            },
+          ],
+        },
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "The weather is nice." }],
+        },
+      ]);
+    });
+
+    it("handles missing toolCallId", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolName: "get_weather",
+              args: { city: "London" },
+            },
+          ],
+        },
+      ]);
+
+      // Tool call should be skipped due to missing toolCallId
+      expect(result).toEqual([]);
+    });
+
+    it("handles missing toolName", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              args: { city: "London" },
+            },
+          ],
+        },
+      ]);
+
+      // Tool call should be skipped due to missing toolName
+      expect(result).toEqual([]);
+    });
+
+    it("defaults args to empty object when missing", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "no_args_tool",
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_123",
+              toolName: "no_args_tool",
+              args: {},
+            },
+          ],
+        },
+      ]);
+    });
+
+    it("handles multiple tool calls with mixed results", () => {
+      const result = toGenericMessages([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "tool_a",
+              args: {},
+              result: "result_a",
+            },
+            {
+              type: "tool-call",
+              toolCallId: "call_2",
+              toolName: "tool_b",
+              args: {},
+              // no result
+            },
+            {
+              type: "tool-call",
+              toolCallId: "call_3",
+              toolName: "tool_c",
+              args: {},
+              result: "result_c",
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call_1",
+              toolName: "tool_a",
+              args: {},
+            },
+            {
+              type: "tool-call",
+              toolCallId: "call_2",
+              toolName: "tool_b",
+              args: {},
+            },
+            {
+              type: "tool-call",
+              toolCallId: "call_3",
+              toolName: "tool_c",
+              args: {},
+            },
+          ],
+        },
+        {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: "call_1",
+              toolName: "tool_a",
+              result: "result_a",
+            },
+            {
+              type: "tool-result",
+              toolCallId: "call_3",
+              toolName: "tool_c",
+              result: "result_c",
+            },
+          ],
+        },
+      ]);
+    });
+  });
+
+  describe("inferImageMediaType", () => {
+    const testMediaType = (url: string, expectedType: string) => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "image", image: url }],
+        },
+      ]);
+      const content = (result[0] as { content: { mediaType: string }[] })
+        .content;
+      expect(content[0]!.mediaType).toBe(expectedType);
+    };
+
+    it("handles jpg extension", () => {
+      testMediaType("https://example.com/photo.jpg", "image/jpeg");
+    });
+
+    it("handles jpeg extension", () => {
+      testMediaType("https://example.com/photo.jpeg", "image/jpeg");
+    });
+
+    it("handles png extension", () => {
+      testMediaType("https://example.com/photo.png", "image/png");
+    });
+
+    it("handles gif extension", () => {
+      testMediaType("https://example.com/photo.gif", "image/gif");
+    });
+
+    it("handles webp extension", () => {
+      testMediaType("https://example.com/photo.webp", "image/webp");
+    });
+
+    it("handles svg extension", () => {
+      testMediaType("https://example.com/icon.svg", "image/svg+xml");
+    });
+
+    it("handles avif extension", () => {
+      testMediaType("https://example.com/photo.avif", "image/avif");
+    });
+
+    it("handles bmp extension", () => {
+      testMediaType("https://example.com/photo.bmp", "image/bmp");
+    });
+
+    it("handles ico extension", () => {
+      testMediaType("https://example.com/favicon.ico", "image/x-icon");
+    });
+
+    it("handles tiff extension", () => {
+      testMediaType("https://example.com/photo.tiff", "image/tiff");
+    });
+
+    it("handles tif extension", () => {
+      testMediaType("https://example.com/photo.tif", "image/tiff");
+    });
+
+    it("defaults to image/png for unknown extension", () => {
+      testMediaType("https://example.com/photo.unknown", "image/png");
+    });
+
+    it("defaults to image/png for no extension", () => {
+      testMediaType("https://example.com/photo", "image/png");
+    });
+
+    it("handles query params in URL", () => {
+      testMediaType(
+        "https://example.com/photo.jpg?size=large&quality=high",
+        "image/jpeg",
+      );
+    });
+
+    it("handles uppercase extensions", () => {
+      testMediaType("https://example.com/photo.JPG", "image/jpeg");
+    });
+  });
+
+  describe("toUrlOrString", () => {
+    it("converts valid URL to URL object", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "image", image: "https://example.com/photo.png" }],
+        },
+      ]);
+      const content = (result[0] as { content: { data: unknown }[] }).content;
+      expect(content[0]!.data).toBeInstanceOf(URL);
+      expect((content[0]!.data as URL).href).toBe(
+        "https://example.com/photo.png",
+      );
+    });
+
+    it("converts data URL to URL object", () => {
+      const dataUrl = "data:image/png;base64,abc123";
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [{ type: "image", image: dataUrl }],
+        },
+      ]);
+      const content = (result[0] as { content: { data: unknown }[] }).content;
+      expect(content[0]!.data).toBeInstanceOf(URL);
+    });
+
+    it("keeps relative path as string", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [
+            { type: "file", data: "/path/to/file.txt", mimeType: "text/plain" },
+          ],
+        },
+      ]);
+      const content = (result[0] as { content: { data: unknown }[] }).content;
+      expect(content[0]!.data).toBe("/path/to/file.txt");
+    });
+
+    it("keeps invalid URL as string", () => {
+      const result = toGenericMessages([
+        {
+          role: "user",
+          content: [
+            { type: "file", data: "not a valid url", mimeType: "text/plain" },
+          ],
+        },
+      ]);
+      const content = (result[0] as { content: { data: unknown }[] }).content;
+      expect(content[0]!.data).toBe("not a valid url");
+    });
+  });
+
+  describe("multiple messages", () => {
+    it("converts a full conversation", () => {
+      const result = toGenericMessages([
+        {
+          role: "system",
+          content: [{ type: "text", text: "You are helpful." }],
+        },
+        {
+          role: "user",
+          content: [{ type: "text", text: "What is 2+2?" }],
+        },
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "2+2 equals 4." }],
+        },
+        {
+          role: "user",
+          content: [{ type: "text", text: "Thanks!" }],
+        },
+      ]);
+
+      expect(result).toEqual([
+        { role: "system", content: "You are helpful." },
+        { role: "user", content: [{ type: "text", text: "What is 2+2?" }] },
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "2+2 equals 4." }],
+        },
+        { role: "user", content: [{ type: "text", text: "Thanks!" }] },
+      ]);
+    });
+
+    it("handles empty messages array", () => {
+      const result = toGenericMessages([]);
+      expect(result).toEqual([]);
+    });
+  });
+});