@kernl-sdk/ai 0.1.1

package/dist/convert/__tests__/stream.test.js

@@ -0,0 +1,389 @@
+import { describe, it, expect } from "vitest";
+import { STREAM_PART, convertStream } from "../stream";
+describe("STREAM_PART codec", () => {
+    describe("decode - text events", () => {
+        it("should decode text-start event", () => {
+            const part = {
+                type: "text-start",
+                id: "text-1",
+                providerMetadata: { openai: { data: "value" } },
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "text-start",
+                id: "text-1",
+                providerMetadata: { openai: { data: "value" } },
+            });
+        });
+        it("should decode text-delta event", () => {
+            const part = {
+                type: "text-delta",
+                id: "text-1",
+                delta: "Hello",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "text-delta",
+                id: "text-1",
+                text: "Hello",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode text-end event", () => {
+            const part = {
+                type: "text-end",
+                id: "text-1",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "text-end",
+                id: "text-1",
+                providerMetadata: undefined,
+            });
+        });
+    });
+    describe("decode - reasoning events", () => {
+        it("should decode reasoning-start event", () => {
+            const part = {
+                type: "reasoning-start",
+                id: "reason-1",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "reasoning-start",
+                id: "reason-1",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode reasoning-delta event", () => {
+            const part = {
+                type: "reasoning-delta",
+                id: "reason-1",
+                delta: "thinking...",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "reasoning-delta",
+                id: "reason-1",
+                text: "thinking...",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode reasoning-end event", () => {
+            const part = {
+                type: "reasoning-end",
+                id: "reason-1",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "reasoning-end",
+                id: "reason-1",
+                providerMetadata: undefined,
+            });
+        });
+    });
+    describe("decode - tool events", () => {
+        it("should decode tool-input-start event", () => {
+            const part = {
+                type: "tool-input-start",
+                id: "tool-1",
+                toolName: "calculator",
+                title: "Calculate",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-input-start",
+                id: "tool-1",
+                toolName: "calculator",
+                title: "Calculate",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode tool-input-delta event", () => {
+            const part = {
+                type: "tool-input-delta",
+                id: "tool-1",
+                delta: "partial input",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-input-delta",
+                id: "tool-1",
+                delta: "partial input",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode tool-input-end event", () => {
+            const part = {
+                type: "tool-input-end",
+                id: "tool-1",
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-input-end",
+                id: "tool-1",
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode tool-call event", () => {
+            const part = {
+                type: "tool-call",
+                toolCallId: "call-123",
+                toolName: "get_weather",
+                input: '{"city":"SF"}',
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-call",
+                id: "call-123",
+                toolName: "get_weather",
+                arguments: '{"city":"SF"}',
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode tool-result event (success)", () => {
+            const part = {
+                type: "tool-result",
+                toolCallId: "call-123",
+                toolName: "get_weather",
+                result: { temperature: 72 },
+                isError: false,
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-result",
+                callId: "call-123",
+                toolId: "get_weather",
+                state: "completed",
+                result: { temperature: 72 },
+                error: null,
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode tool-result event (error)", () => {
+            const part = {
+                type: "tool-result",
+                toolCallId: "call-123",
+                toolName: "get_weather",
+                result: "Network error",
+                isError: true,
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "tool-result",
+                callId: "call-123",
+                toolId: "get_weather",
+                state: "failed",
+                result: "Network error",
+                error: "Network error",
+                providerMetadata: undefined,
+            });
+        });
+    });
+    describe("decode - stream control events", () => {
+        it("should decode stream-start event", () => {
+            const part = {
+                type: "stream-start",
+                warnings: [
+                    {
+                        type: "unsupported-setting",
+                        setting: "topK",
+                    },
+                ],
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "stream-start",
+                warnings: [
+                    {
+                        type: "unsupported-setting",
+                        setting: "topK",
+                        details: undefined,
+                    },
+                ],
+            });
+        });
+        it("should decode finish event", () => {
+            const part = {
+                type: "finish",
+                finishReason: "stop",
+                usage: {
+                    inputTokens: 10,
+                    outputTokens: 20,
+                    totalTokens: 30,
+                },
+                providerMetadata: undefined,
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "finish",
+                finishReason: "stop",
+                usage: {
+                    inputTokens: 10,
+                    outputTokens: 20,
+                    totalTokens: 30,
+                    reasoningTokens: undefined,
+                    cachedInputTokens: undefined,
+                },
+                providerMetadata: undefined,
+            });
+        });
+        it("should decode error event", () => {
+            const part = {
+                type: "error",
+                error: "Connection failed",
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "error",
+                error: "Connection failed",
+            });
+        });
+        it("should decode raw event", () => {
+            const part = {
+                type: "raw",
+                rawValue: { custom: "data" },
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "raw",
+                rawValue: { custom: "data" },
+            });
+        });
+        it("should return null for response-metadata", () => {
+            const part = {
+                type: "response-metadata",
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toBeNull();
+        });
+    });
+    describe("decode - file and source events", () => {
+        it("should decode file event as raw", () => {
+            const part = {
+                type: "file",
+                id: "file-1",
+                filename: "test.txt",
+                mediaType: "text/plain",
+                data: "base64data",
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "raw",
+                rawValue: part,
+            });
+        });
+        it("should decode source event as raw", () => {
+            const part = {
+                type: "source",
+                sourceType: "url",
+                id: "source-1",
+                url: "https://example.com",
+            };
+            const result = STREAM_PART.decode(part);
+            expect(result).toEqual({
+                kind: "raw",
+                rawValue: part,
+            });
+        });
+    });
+    describe("encode", () => {
+        it("should throw unimplemented error", () => {
+            expect(() => STREAM_PART.encode(null)).toThrow("codec:unimplemented");
+        });
+    });
+});
+describe("convertStream", () => {
+    it("should convert stream to async iterable", async () => {
+        const parts = [
+            { type: "text-start", id: "text-1", providerMetadata: undefined },
+            {
+                type: "text-delta",
+                id: "text-1",
+                delta: "Hello",
+                providerMetadata: undefined,
+            },
+            { type: "text-end", id: "text-1", providerMetadata: undefined },
+            {
+                type: "finish",
+                finishReason: "stop",
+                usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+                providerMetadata: undefined,
+            },
+        ];
+        const stream = new ReadableStream({
+            start(controller) {
+                for (const part of parts) {
+                    controller.enqueue(part);
+                }
+                controller.close();
+            },
+        });
+        const events = [];
+        for await (const event of convertStream(stream)) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(4);
+        expect(events[0]).toMatchObject({ kind: "text-start" });
+        expect(events[1]).toMatchObject({ kind: "text-delta", text: "Hello" });
+        expect(events[2]).toMatchObject({ kind: "text-end" });
+        expect(events[3]).toMatchObject({ kind: "finish", finishReason: "stop" });
+    });
+    it("should filter out null events", async () => {
+        const parts = [
+            {
+                type: "text-delta",
+                id: "text-1",
+                delta: "Hello",
+                providerMetadata: undefined,
+            },
+            {
+                type: "response-metadata",
+            }, // This should be filtered out
+            {
+                type: "finish",
+                finishReason: "stop",
+                usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+                providerMetadata: undefined,
+            },
+        ];
+        const stream = new ReadableStream({
+            start(controller) {
+                for (const part of parts) {
+                    controller.enqueue(part);
+                }
+                controller.close();
+            },
+        });
+        const events = [];
+        for await (const event of convertStream(stream)) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(2);
+        expect(events[0]).toMatchObject({ kind: "text-delta" });
+        expect(events[1]).toMatchObject({ kind: "finish" });
+    });
+    it("should handle empty stream", async () => {
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
+        });
+        const events = [];
+        for await (const event of convertStream(stream)) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(0);
+    });
+});

package/dist/convert/__tests__/tools.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tools.test.d.ts.map

package/dist/convert/__tests__/tools.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.test.d.ts","sourceRoot":"","sources":["../../../src/convert/__tests__/tools.test.ts"],"names":[],"mappings":""}

package/dist/convert/__tests__/tools.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from "vitest";
+import { TOOL, TOOL_CHOICE } from "../tools";
+describe("TOOL codec", () => {
+    describe("encode - function tools", () => {
+        it("should encode function tool with basic schema", () => {
+            const result = TOOL.encode({
+                kind: "function",
+                name: "get_weather",
+                description: "Get current weather for a location",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        city: { type: "string" },
+                    },
+                    required: ["city"],
+                },
+            });
+            expect(result).toEqual({
+                type: "function",
+                name: "get_weather",
+                description: "Get current weather for a location",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        city: { type: "string" },
+                    },
+                    required: ["city"],
+                },
+                providerOptions: undefined,
+            });
+        });
+        it("should encode function tool without description", () => {
+            const result = TOOL.encode({
+                kind: "function",
+                name: "simple_tool",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            });
+            expect(result).toEqual({
+                type: "function",
+                name: "simple_tool",
+                description: undefined,
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+                providerOptions: undefined,
+            });
+        });
+        it("should encode function tool with complex schema", () => {
+            const result = TOOL.encode({
+                kind: "function",
+                name: "search",
+                description: "Search for information",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query",
+                        },
+                        filters: {
+                            type: "object",
+                            properties: {
+                                category: { type: "string" },
+                                maxResults: { type: "number" },
+                            },
+                        },
+                    },
+                    required: ["query"],
+                },
+            });
+            expect(result.type).toBe("function");
+            expect(result.name).toBe("search");
+            if (result.type === "function" && result.inputSchema.properties) {
+                expect(result.inputSchema.properties.query).toEqual({
+                    type: "string",
+                    description: "Search query",
+                });
+                expect(result.inputSchema.required).toEqual(["query"]);
+            }
+        });
+    });
+    describe("encode - provider-defined tools", () => {
+        it("should encode provider-defined tool", () => {
+            const result = TOOL.encode({
+                kind: "provider-defined",
+                id: "mcp.tool-123",
+                name: "custom_mcp_tool",
+                args: { param1: "value1" },
+            });
+            expect(result).toEqual({
+                type: "provider-defined",
+                id: "mcp.tool-123",
+                name: "custom_mcp_tool",
+                args: { param1: "value1" },
+            });
+        });
+        it("should encode provider-defined tool without args", () => {
+            const result = TOOL.encode({
+                kind: "provider-defined",
+                id: "mcp.tool-id",
+                name: "tool_name",
+                args: {},
+            });
+            expect(result).toEqual({
+                type: "provider-defined",
+                id: "mcp.tool-id",
+                name: "tool_name",
+                args: {},
+            });
+        });
+    });
+    describe("decode", () => {
+        it("should throw unimplemented error", () => {
+            expect(() => TOOL.decode({})).toThrow("codec:unimplemented");
+        });
+    });
+});
+describe("TOOL_CHOICE codec", () => {
+    describe("encode", () => {
+        it("should encode 'auto' tool choice", () => {
+            const result = TOOL_CHOICE.encode({ kind: "auto" });
+            expect(result).toEqual({ type: "auto" });
+        });
+        it("should encode 'none' tool choice", () => {
+            const result = TOOL_CHOICE.encode({ kind: "none" });
+            expect(result).toEqual({ type: "none" });
+        });
+        it("should encode 'required' tool choice", () => {
+            const result = TOOL_CHOICE.encode({ kind: "required" });
+            expect(result).toEqual({ type: "required" });
+        });
+        it("should encode specific tool choice", () => {
+            const result = TOOL_CHOICE.encode({
+                kind: "tool",
+                toolId: "get_weather",
+            });
+            expect(result).toEqual({
+                type: "tool",
+                toolName: "get_weather",
+            });
+        });
+    });
+    describe("decode", () => {
+        it("should throw unimplemented error", () => {
+            expect(() => TOOL_CHOICE.decode({})).toThrow("codec:unimplemented");
+        });
+    });
+});

package/dist/convert/message.d.ts

@@ -0,0 +1,4 @@
+import type { Codec, LanguageModelItem } from "@kernl-sdk/protocol";
+import type { LanguageModelV3Message } from "@ai-sdk/provider";
+export declare const MESSAGE: Codec<LanguageModelItem, LanguageModelV3Message>;
+//# sourceMappingURL=message.d.ts.map

package/dist/convert/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/convert/message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EACV,sBAAsB,EAKvB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,iBAAiB,EAAE,sBAAsB,CA4IpE,CAAC"}

package/dist/convert/message.js

@@ -0,0 +1,122 @@
+export const MESSAGE = {
+    encode: (item) => {
+        switch (item.kind) {
+            case "message": {
+                switch (item.role) {
+                    case "system": {
+                        const content = item.content
+                            .filter((part) => part.kind === "text")
+                            .map((part) => (part.kind === "text" ? part.text : ""))
+                            .join("\n");
+                        return {
+                            role: "system",
+                            content: content,
+                            providerOptions: item.providerMetadata,
+                        };
+                    }
+                    case "user": {
+                        const content = [];
+                        for (const part of item.content) {
+                            if (part.kind === "text") {
+                                content.push({
+                                    type: "text",
+                                    text: part.text,
+                                    providerOptions: part.providerMetadata,
+                                });
+                            }
+                            else if (part.kind === "file") {
+                                content.push({
+                                    type: "file",
+                                    filename: part.filename,
+                                    data: part.data,
+                                    mediaType: part.mimeType,
+                                    providerOptions: part.providerMetadata,
+                                });
+                            }
+                        }
+                        return {
+                            role: "user",
+                            content,
+                            providerOptions: item.providerMetadata,
+                        };
+                    }
+                    case "assistant": {
+                        const content = [];
+                        for (const part of item.content) {
+                            if (part.kind === "text") {
+                                content.push({
+                                    type: "text",
+                                    text: part.text,
+                                    providerOptions: part.providerMetadata,
+                                });
+                            }
+                            else if (part.kind === "file") {
+                                content.push({
+                                    type: "file",
+                                    filename: part.filename,
+                                    data: part.data,
+                                    mediaType: part.mimeType,
+                                    providerOptions: part.providerMetadata,
+                                });
+                            }
+                        }
+                        return {
+                            role: "assistant",
+                            content,
+                            providerOptions: item.providerMetadata,
+                        };
+                    }
+                }
+                break;
+            }
+            case "reasoning": {
+                return {
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "reasoning",
+                            text: "text" in item ? item.text : "",
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                };
+            }
+            case "tool-call": {
+                return {
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "tool-call",
+                            toolCallId: item.callId,
+                            toolName: item.toolId,
+                            input: JSON.parse(item.arguments),
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                };
+            }
+            case "tool-result": {
+                return {
+                    role: "tool",
+                    content: [
+                        {
+                            type: "tool-result",
+                            toolCallId: item.callId,
+                            toolName: item.toolId,
+                            output: {
+                                type: "json",
+                                value: item.result,
+                            },
+                            providerOptions: item.providerMetadata,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unsupported LanguageModelItem kind: ${item.kind}`);
+        }
+    },
+    decode: () => {
+        throw new Error("codec:unimplemented");
+    },
+};

package/dist/convert/messages.d.ts

@@ -0,0 +1,4 @@
+import type { Codec, LanguageModelItem } from "@kernl-sdk/protocol";
+import type { LanguageModelV3Message } from "ai";
+export declare const messages: Codec<LanguageModelItem[], LanguageModelV3Message[]>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/convert/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/convert/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,EACV,sBAAsB,EAMvB,MAAM,IAAI,CAAC;AAEZ,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,iBAAiB,EAAE,EAAE,sBAAsB,EAAE,CAwIzE,CAAC"}