@kernl-sdk/ai 0.1.1

package/src/convert/__tests__/message.test.ts

@@ -0,0 +1,336 @@
+import { describe, it, expect } from "vitest";
+import type { LanguageModelV3Message } from "@ai-sdk/provider";
+
+import { MESSAGE } from "../message";
+
+describe("MESSAGE codec", () => {
+  describe("encode - system messages", () => {
+    it("should encode system message with single text part", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "system",
+        id: "msg-1",
+        content: [{ kind: "text", text: "You are a helpful assistant." }],
+      });
+
+      expect(result).toEqual({
+        role: "system",
+        content: "You are a helpful assistant.",
+        providerOptions: undefined,
+      });
+    });
+
+    it("should encode system message with multiple text parts", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "system",
+        id: "msg-1",
+        content: [
+          { kind: "text", text: "You are helpful." },
+          { kind: "text", text: "You are concise." },
+        ],
+      });
+
+      expect(result).toEqual({
+        role: "system",
+        content: "You are helpful.\nYou are concise.",
+        providerOptions: undefined,
+      });
+    });
+
+    it("should filter out non-text parts from system messages", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "system",
+        id: "msg-1",
+        content: [
+          { kind: "text", text: "System prompt" },
+          { kind: "file", data: "base64data", mimeType: "image/png" },
+        ],
+      });
+
+      expect(result).toEqual({
+        role: "system",
+        content: "System prompt",
+        providerOptions: undefined,
+      });
+    });
+
+    it("should include providerMetadata when present", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "system",
+        id: "msg-1",
+        content: [{ kind: "text", text: "System" }],
+        providerMetadata: { openai: { custom: "metadata" } },
+      });
+
+      expect(result).toEqual({
+        role: "system",
+        content: "System",
+        providerOptions: { openai: { custom: "metadata" } },
+      });
+    });
+  });
+
+  describe("encode - user messages", () => {
+    it("should encode user message with text part", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "user",
+        id: "msg-1",
+        content: [{ kind: "text", text: "Hello!" }],
+      });
+
+      expect(result).toEqual({
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "Hello!",
+            providerOptions: undefined,
+          },
+        ],
+        providerOptions: undefined,
+      });
+    });
+
+    it("should encode user message with file part", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "user",
+        id: "msg-1",
+        content: [
+          {
+            kind: "file",
+            data: "base64imagedata",
+            mimeType: "image/png",
+            filename: "screenshot.png",
+          },
+        ],
+      });
+
+      expect(result).toEqual({
+        role: "user",
+        content: [
+          {
+            type: "file",
+            filename: "screenshot.png",
+            data: "base64imagedata",
+            mediaType: "image/png",
+            providerOptions: undefined,
+          },
+        ],
+        providerOptions: undefined,
+      });
+    });
+
+    it("should encode user message with mixed text and file parts", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "user",
+        id: "msg-1",
+        content: [
+          { kind: "text", text: "Look at this:" },
+          {
+            kind: "file",
+            data: "base64data",
+            mimeType: "image/jpeg" as const,
+          },
+        ],
+      });
+
+      expect(result.role).toBe("user");
+      expect(result.content).toHaveLength(2);
+      expect(result.content[0]).toEqual({
+        type: "text",
+        text: "Look at this:",
+        providerOptions: undefined,
+      });
+      expect(result.content[1]).toEqual({
+        type: "file",
+        filename: undefined,
+        data: "base64data",
+        mediaType: "image/jpeg",
+        providerOptions: undefined,
+      });
+    });
+  });
+
+  describe("encode - assistant messages", () => {
+    it("should encode assistant message with text part", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "assistant",
+        id: "msg-1",
+        content: [{ kind: "text", text: "I can help with that." }],
+      });
+
+      expect(result).toEqual({
+        role: "assistant",
+        content: [
+          {
+            type: "text",
+            text: "I can help with that.",
+            providerOptions: undefined,
+          },
+        ],
+        providerOptions: undefined,
+      });
+    });
+
+    it("should encode assistant message with file part", () => {
+      const result = MESSAGE.encode({
+        kind: "message",
+        role: "assistant",
+        id: "msg-1",
+        content: [
+          {
+            kind: "file",
+            data: "chartdata",
+            mimeType: "image/svg+xml" as const,
+          },
+        ],
+      });
+
+      expect(result).toEqual({
+        role: "assistant",
+        content: [
+          {
+            type: "file",
+            filename: undefined,
+            data: "chartdata",
+            mediaType: "image/svg+xml",
+            providerOptions: undefined,
+          },
+        ],
+        providerOptions: undefined,
+      });
+    });
+  });
+
+  describe("encode - tool-call items", () => {
+    it("should encode tool-call item", () => {
+      const result = MESSAGE.encode({
+        kind: "tool-call",
+        callId: "call-123",
+        toolId: "get_weather",
+        state: "completed",
+        arguments: JSON.stringify({ city: "SF" }),
+      });
+
+      expect(result).toEqual({
+        role: "assistant",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-123",
+            toolName: "get_weather",
+            input: { city: "SF" },
+            providerOptions: undefined,
+          },
+        ],
+      });
+    });
+
+    it("should include providerMetadata for tool-call", () => {
+      const result = MESSAGE.encode({
+        kind: "tool-call",
+        callId: "call-123",
+        toolId: "get_weather",
+        state: "completed",
+        arguments: JSON.stringify({ city: "SF" }),
+        providerMetadata: { anthropic: { executionTime: 150 } },
+      });
+
+      expect(result.content[0]).toMatchObject({
+        type: "tool-call",
+        providerOptions: { anthropic: { executionTime: 150 } },
+      });
+    });
+  });
+
+  describe("encode - tool-result items", () => {
+    it("should encode tool-result item", () => {
+      const result = MESSAGE.encode({
+        kind: "tool-result",
+        callId: "call-123",
+        toolId: "get_weather",
+        state: "completed",
+        result: { temp: 72, conditions: "sunny" },
+        error: null,
+      });
+
+      expect(result).toEqual({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "call-123",
+            toolName: "get_weather",
+            output: {
+              type: "json",
+              value: { temp: 72, conditions: "sunny" },
+            },
+            providerOptions: undefined,
+          },
+        ],
+      });
+    });
+  });
+
+  describe("encode - reasoning items", () => {
+    it("should encode reasoning item with text", () => {
+      const result = MESSAGE.encode({
+        kind: "reasoning",
+        text: "Let me think about this step by step...",
+      });
+
+      expect(result).toEqual({
+        role: "assistant",
+        content: [
+          {
+            type: "reasoning",
+            text: "Let me think about this step by step...",
+            providerOptions: undefined,
+          },
+        ],
+      });
+    });
+
+    it("should encode reasoning item without text field", () => {
+      const result = MESSAGE.encode({
+        kind: "reasoning",
+      } as any);
+
+      expect(result).toEqual({
+        role: "assistant",
+        content: [
+          {
+            type: "reasoning",
+            text: "",
+            providerOptions: undefined,
+          },
+        ],
+      });
+    });
+  });
+
+  describe("encode - unsupported items", () => {
+    it("should throw error for unsupported item kind", () => {
+      expect(() =>
+        MESSAGE.encode({
+          kind: "unknown-kind",
+        } as any),
+      ).toThrow("Unsupported LanguageModelItem kind: unknown-kind");
+    });
+  });
+
+  describe("decode", () => {
+    it("should throw unimplemented error", () => {
+      expect(() => MESSAGE.decode({} as LanguageModelV3Message)).toThrow(
+        "codec:unimplemented",
+      );
+    });
+  });
+});

package/src/convert/__tests__/response.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import type { LanguageModelV3CallWarning } from "@ai-sdk/provider";
+
+import { WARNING } from "../response";
+
+describe("WARNING codec", () => {
+  describe("decode", () => {
+    it("should decode unsupported-setting warning", () => {
+      const aiWarning: LanguageModelV3CallWarning = {
+        type: "unsupported-setting",
+        setting: "someUnsupportedSetting",
+        details: "This setting is not supported by the provider",
+      };
+
+      const result = WARNING.decode(aiWarning);
+
+      expect(result).toEqual({
+        type: "unsupported-setting",
+        setting: "someUnsupportedSetting",
+        details: "This setting is not supported by the provider",
+      });
+    });
+
+    it("should decode other warning", () => {
+      const aiWarning: LanguageModelV3CallWarning = {
+        type: "other",
+        message: "Some custom warning message",
+      };
+
+      const result = WARNING.decode(aiWarning);
+
+      expect(result).toEqual({
+        type: "other",
+        message: "Some custom warning message",
+      });
+    });
+
+    it("should handle unknown warning type", () => {
+      const aiWarning = {
+        type: "unknown-type",
+        someField: "value",
+      } as any;
+
+      const result = WARNING.decode(aiWarning);
+
+      expect(result).toEqual({
+        type: "other",
+        message: "Unknown warning type",
+      });
+    });
+  });
+
+  describe("encode", () => {
+    it("should throw unimplemented error", () => {
+      expect(() =>
+        WARNING.encode({
+          type: "other",
+          message: "test",
+        }),
+      ).toThrow("codec:unimplemented");
+    });
+  });
+});

package/src/convert/__tests__/settings.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from "vitest";
+import type { LanguageModelRequestSettings } from "@kernl-sdk/protocol";
+
+import { MODEL_SETTINGS } from "../settings";
+
+describe("MODEL_SETTINGS codec", () => {
+  describe("encode", () => {
+    it("should encode temperature setting", () => {
+      const settings: LanguageModelRequestSettings = {
+        temperature: 0.7,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        temperature: 0.7,
+      });
+    });
+
+    it("should encode topP setting", () => {
+      const settings: LanguageModelRequestSettings = {
+        topP: 0.9,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        topP: 0.9,
+      });
+    });
+
+    it("should encode maxTokens setting", () => {
+      const settings: LanguageModelRequestSettings = {
+        maxTokens: 1000,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        maxOutputTokens: 1000,
+      });
+    });
+
+    it("should encode frequencyPenalty setting", () => {
+      const settings: LanguageModelRequestSettings = {
+        frequencyPenalty: 0.5,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        frequencyPenalty: 0.5,
+      });
+    });
+
+    it("should encode presencePenalty setting", () => {
+      const settings: LanguageModelRequestSettings = {
+        presencePenalty: 0.3,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        presencePenalty: 0.3,
+      });
+    });
+
+    it("should encode toolChoice 'auto'", () => {
+      const settings: LanguageModelRequestSettings = {
+        toolChoice: { kind: "auto" },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        toolChoice: { type: "auto" },
+      });
+    });
+
+    it("should encode toolChoice 'none'", () => {
+      const settings: LanguageModelRequestSettings = {
+        toolChoice: { kind: "none" },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        toolChoice: { type: "none" },
+      });
+    });
+
+    it("should encode toolChoice 'required'", () => {
+      const settings: LanguageModelRequestSettings = {
+        toolChoice: { kind: "required" },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        toolChoice: { type: "required" },
+      });
+    });
+
+    it("should encode toolChoice with specific tool", () => {
+      const settings: LanguageModelRequestSettings = {
+        toolChoice: { kind: "tool", toolId: "get_weather" },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        toolChoice: { type: "tool", toolName: "get_weather" },
+      });
+    });
+
+    it("should encode providerOptions", () => {
+      const settings: LanguageModelRequestSettings = {
+        providerOptions: {
+          anthropic: {
+            cacheControl: { type: "ephemeral" },
+          },
+        },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        providerOptions: {
+          anthropic: {
+            cacheControl: { type: "ephemeral" },
+          },
+        },
+      });
+    });
+
+    it("should encode multiple settings together", () => {
+      const settings: LanguageModelRequestSettings = {
+        temperature: 0.8,
+        maxTokens: 2000,
+        topP: 0.95,
+        frequencyPenalty: 0.2,
+        presencePenalty: 0.1,
+        toolChoice: { kind: "auto" },
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        temperature: 0.8,
+        maxOutputTokens: 2000,
+        topP: 0.95,
+        frequencyPenalty: 0.2,
+        presencePenalty: 0.1,
+        toolChoice: { type: "auto" },
+      });
+    });
+
+    it("should handle empty settings", () => {
+      const settings: LanguageModelRequestSettings = {};
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({});
+    });
+
+    it("should only include defined settings", () => {
+      const settings: LanguageModelRequestSettings = {
+        temperature: 0.5,
+        maxTokens: undefined,
+      };
+
+      const result = MODEL_SETTINGS.encode(settings);
+
+      expect(result).toEqual({
+        temperature: 0.5,
+      });
+      expect(result).not.toHaveProperty("maxTokens");
+    });
+  });
+
+  describe("decode", () => {
+    it("should throw unimplemented error", () => {
+      expect(() => MODEL_SETTINGS.decode({} as any)).toThrow(
+        "codec:unimplemented",
+      );
+    });
+  });
+});