@kernl-sdk/ai 0.1.1 → 0.1.2

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @kernl-sdk/ai@0.1.1 build /Users/andjones/Documents/projects/kernl/packages/_ai
+> @kernl-sdk/ai@0.1.2 build /Users/andjones/Documents/projects/kernl/packages/_ai
 > tsc && tsc-alias
 

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @kernl/ai
 
+## 0.1.2
+
+### Patch Changes
+
+- Minor bug fixes and improvements
+- Updated dependencies
+  - @kernl-sdk/protocol@0.2.1
+  - @kernl-sdk/shared@0.1.2
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/__tests__/integration.test.js

@@ -221,6 +221,57 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             const finishEvents = events.filter((e) => e.kind === "finish");
             expect(finishEvents.length).toBe(1);
         });
+        it("should yield both delta events and complete Message items", async () => {
+            const events = [];
+            for await (const event of gpt4omini.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [
+                            { kind: "text", text: "Say 'Hello World' and nothing else." },
+                        ],
+                    },
+                ],
+                settings: {
+                    maxTokens: 50,
+                    temperature: 0,
+                },
+            })) {
+                events.push(event);
+            }
+            expect(events.length).toBeGreaterThan(0);
+            // Should have text-delta events (for streaming UX)
+            const textDeltas = events.filter((e) => e.kind === "text-delta");
+            expect(textDeltas.length).toBeGreaterThan(0);
+            // Should have text-start event
+            const textStarts = events.filter((e) => e.kind === "text-start");
+            expect(textStarts.length).toBeGreaterThan(0);
+            // Should have text-end event
+            const textEnds = events.filter((e) => e.kind === "text-end");
+            expect(textEnds.length).toBeGreaterThan(0);
+            // Should have complete Message item (for history)
+            const messages = events.filter((e) => e.kind === "message");
+            expect(messages.length).toBeGreaterThan(0);
+            const assistantMessage = messages[0];
+            expect(assistantMessage.role).toBe("assistant");
+            expect(assistantMessage.content).toBeDefined();
+            expect(assistantMessage.content.length).toBeGreaterThan(0);
+            // Message should have accumulated text from all deltas
+            const textContent = assistantMessage.content.find((c) => c.kind === "text");
+            expect(textContent).toBeDefined();
+            expect(textContent.text).toBeDefined();
+            expect(textContent.text.length).toBeGreaterThan(0);
+            // Verify accumulated text matches concatenated deltas
+            const accumulatedFromDeltas = textDeltas
+                .map((d) => d.text)
+                .join("");
+            expect(textContent.text).toBe(accumulatedFromDeltas);
+            // Should have finish event
+            const finishEvents = events.filter((e) => e.kind === "finish");
+            expect(finishEvents.length).toBe(1);
+        });
     });
     describe("tools", () => {
         it("should call tools when requested", async () => {
@@ -350,6 +401,92 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             const toolCalls = response.content.filter((item) => item.kind === "tool-call");
             expect(toolCalls.length).toBeGreaterThan(0);
         });
+        it("should handle multi-turn conversation with tool results", async () => {
+            // First turn: get tool calls from the model
+            const firstResponse = await gpt4omini.generate({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "What is 25 + 17?" }],
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "calculate",
+                        description: "Perform a mathematical calculation",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                expression: {
+                                    type: "string",
+                                    description: "The mathematical expression to evaluate",
+                                },
+                            },
+                            required: ["expression"],
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                },
+            });
+            expect(firstResponse.content).toBeDefined();
+            // Extract tool calls
+            const toolCalls = firstResponse.content.filter((item) => item.kind === "tool-call");
+            expect(toolCalls.length).toBeGreaterThan(0);
+            const toolCall = toolCalls[0];
+            expect(toolCall.callId).toBeDefined();
+            expect(toolCall.toolId).toBe("calculate");
+            // Second turn: send tool results back to the model
+            const secondResponse = await gpt4omini.generate({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "What is 25 + 17?" }],
+                    },
+                    ...firstResponse.content,
+                    {
+                        kind: "tool-result",
+                        callId: toolCall.callId,
+                        toolId: toolCall.toolId,
+                        state: "completed",
+                        result: { answer: 42 },
+                        error: null,
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "calculate",
+                        description: "Perform a mathematical calculation",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                expression: {
+                                    type: "string",
+                                    description: "The mathematical expression to evaluate",
+                                },
+                            },
+                            required: ["expression"],
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                },
+            });
+            expect(secondResponse.content).toBeDefined();
+            // Should have an assistant message with the final answer
+            const messages = secondResponse.content.filter((item) => item.kind === "message" && item.role === "assistant");
+            expect(messages.length).toBeGreaterThan(0);
+        });
     });
     describe("validation", () => {
         it("should throw error for invalid maxTokens", async () => {

package/dist/__tests__/language-model.test.d.ts

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

package/dist/__tests__/language-model.test.d.ts.map

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

package/dist/__tests__/language-model.test.js

@@ -0,0 +1,423 @@
+import { describe, it, expect, vi } from "vitest";
+import { AISDKLanguageModel } from "../language-model";
+/**
+ * Unit tests for AISDKLanguageModel stream accumulation behavior
+ */
+describe("AISDKLanguageModel", () => {
+    describe("stream - delta accumulation", () => {
+        it("should yield delta events and complete Message on text-end", async () => {
+            // Mock the underlying AI SDK model
+            const mockModel = {
+                provider: "test",
+                modelId: "test-model",
+                doStream: vi.fn().mockResolvedValue({
+                    stream: new ReadableStream({
+                        start(controller) {
+                            const parts = [
+                                {
+                                    type: "text-start",
+                                    id: "text-1",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-delta",
+                                    id: "text-1",
+                                    delta: "Hello",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-delta",
+                                    id: "text-1",
+                                    delta: " ",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-delta",
+                                    id: "text-1",
+                                    delta: "World",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-end",
+                                    id: "text-1",
+                                    providerMetadata: { test: { foo: "bar" } },
+                                },
+                                {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        inputTokens: 5,
+                                        outputTokens: 10,
+                                        totalTokens: 15,
+                                    },
+                                    providerMetadata: undefined,
+                                },
+                            ];
+                            for (const part of parts) {
+                                controller.enqueue(part);
+                            }
+                            controller.close();
+                        },
+                    }),
+                }),
+            };
+            const model = new AISDKLanguageModel(mockModel);
+            const events = [];
+            for await (const event of model.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "Hi" }],
+                    },
+                ],
+                settings: {},
+            })) {
+                events.push(event);
+            }
+            // Should have: start, 3 deltas, end, complete Message, finish
+            expect(events).toHaveLength(7);
+            // Check delta events
+            expect(events[0]).toMatchObject({ kind: "text-start", id: "text-1" });
+            expect(events[1]).toMatchObject({
+                kind: "text-delta",
+                id: "text-1",
+                text: "Hello",
+            });
+            expect(events[2]).toMatchObject({
+                kind: "text-delta",
+                id: "text-1",
+                text: " ",
+            });
+            expect(events[3]).toMatchObject({
+                kind: "text-delta",
+                id: "text-1",
+                text: "World",
+            });
+            // Check complete Message item (yielded before end event)
+            const messageEvent = events[4];
+            expect(messageEvent.kind).toBe("message");
+            expect(messageEvent).toMatchObject({
+                kind: "message",
+                role: "assistant",
+                content: [
+                    {
+                        kind: "text",
+                        text: "Hello World", // Accumulated text
+                    },
+                ],
+                providerMetadata: { test: { foo: "bar" } }, // From end event
+            });
+            expect(messageEvent.id).toBeDefined();
+            // Check end event (yielded after Message)
+            expect(events[5]).toMatchObject({ kind: "text-end", id: "text-1" });
+            // Check finish event
+            expect(events[6]).toMatchObject({ kind: "finish" });
+        });
+        it("should yield delta events and complete Reasoning on reasoning-end", async () => {
+            const mockModel = {
+                provider: "test",
+                modelId: "test-model",
+                doStream: vi.fn().mockResolvedValue({
+                    stream: new ReadableStream({
+                        start(controller) {
+                            const parts = [
+                                {
+                                    type: "reasoning-start",
+                                    id: "reason-1",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "reasoning-delta",
+                                    id: "reason-1",
+                                    delta: "Let me think",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "reasoning-delta",
+                                    id: "reason-1",
+                                    delta: " about this",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "reasoning-end",
+                                    id: "reason-1",
+                                    providerMetadata: { test: { reasoning: true } },
+                                },
+                                {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        inputTokens: 5,
+                                        outputTokens: 20,
+                                        totalTokens: 25,
+                                    },
+                                    providerMetadata: undefined,
+                                },
+                            ];
+                            for (const part of parts) {
+                                controller.enqueue(part);
+                            }
+                            controller.close();
+                        },
+                    }),
+                }),
+            };
+            const model = new AISDKLanguageModel(mockModel);
+            const events = [];
+            for await (const event of model.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "Think about this" }],
+                    },
+                ],
+                settings: {},
+            })) {
+                events.push(event);
+            }
+            // Should have: start, 2 deltas, end, complete Reasoning, finish
+            expect(events).toHaveLength(6);
+            // Check delta events
+            expect(events[0]).toMatchObject({
+                kind: "reasoning-start",
+                id: "reason-1",
+            });
+            expect(events[1]).toMatchObject({
+                kind: "reasoning-delta",
+                id: "reason-1",
+                text: "Let me think",
+            });
+            expect(events[2]).toMatchObject({
+                kind: "reasoning-delta",
+                id: "reason-1",
+                text: " about this",
+            });
+            // Check complete Reasoning item (yielded before end event)
+            const reasoningEvent = events[3];
+            expect(reasoningEvent.kind).toBe("reasoning");
+            expect(reasoningEvent).toMatchObject({
+                kind: "reasoning",
+                text: "Let me think about this", // Accumulated text
+                providerMetadata: { test: { reasoning: true } }, // From end event
+            });
+            expect(reasoningEvent.id).toBeDefined();
+            // Check end event (yielded after Reasoning)
+            expect(events[4]).toMatchObject({
+                kind: "reasoning-end",
+                id: "reason-1",
+            });
+            // Check finish event
+            expect(events[5]).toMatchObject({ kind: "finish" });
+        });
+        it("should handle multiple text blocks with different IDs", async () => {
+            const mockModel = {
+                provider: "test",
+                modelId: "test-model",
+                doStream: vi.fn().mockResolvedValue({
+                    stream: new ReadableStream({
+                        start(controller) {
+                            const parts = [
+                                { type: "text-start", id: "text-1", providerMetadata: undefined },
+                                {
+                                    type: "text-delta",
+                                    id: "text-1",
+                                    delta: "First",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-end",
+                                    id: "text-1",
+                                    providerMetadata: { test: { order: 1 } },
+                                },
+                                { type: "text-start", id: "text-2", providerMetadata: undefined },
+                                {
+                                    type: "text-delta",
+                                    id: "text-2",
+                                    delta: "Second",
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "text-end",
+                                    id: "text-2",
+                                    providerMetadata: { test: { order: 2 } },
+                                },
+                                {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        inputTokens: 5,
+                                        outputTokens: 10,
+                                        totalTokens: 15,
+                                    },
+                                    providerMetadata: undefined,
+                                },
+                            ];
+                            for (const part of parts) {
+                                controller.enqueue(part);
+                            }
+                            controller.close();
+                        },
+                    }),
+                }),
+            };
+            const model = new AISDKLanguageModel(mockModel);
+            const events = [];
+            for await (const event of model.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "Hi" }],
+                    },
+                ],
+                settings: {},
+            })) {
+                events.push(event);
+            }
+            // Check we got two separate Message items
+            const messageEvents = events.filter((e) => e.kind === "message");
+            expect(messageEvents).toHaveLength(2);
+            expect(messageEvents[0]).toMatchObject({
+                kind: "message",
+                role: "assistant",
+                content: [{ kind: "text", text: "First" }],
+                providerMetadata: { test: { order: 1 } },
+            });
+            expect(messageEvents[1]).toMatchObject({
+                kind: "message",
+                role: "assistant",
+                content: [{ kind: "text", text: "Second" }],
+                providerMetadata: { test: { order: 2 } },
+            });
+        });
+        it("should use metadata from end event (last-wins)", async () => {
+            const mockModel = {
+                provider: "test",
+                modelId: "test-model",
+                doStream: vi.fn().mockResolvedValue({
+                    stream: new ReadableStream({
+                        start(controller) {
+                            const parts = [
+                                {
+                                    type: "text-start",
+                                    id: "text-1",
+                                    providerMetadata: { test: { version: "start" } },
+                                },
+                                {
+                                    type: "text-delta",
+                                    id: "text-1",
+                                    delta: "Test",
+                                    providerMetadata: { test: { version: "delta" } },
+                                },
+                                {
+                                    type: "text-end",
+                                    id: "text-1",
+                                    providerMetadata: { test: { version: "end" } },
+                                },
+                                {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        inputTokens: 5,
+                                        outputTokens: 10,
+                                        totalTokens: 15,
+                                    },
+                                    providerMetadata: undefined,
+                                },
+                            ];
+                            for (const part of parts) {
+                                controller.enqueue(part);
+                            }
+                            controller.close();
+                        },
+                    }),
+                }),
+            };
+            const model = new AISDKLanguageModel(mockModel);
+            const events = [];
+            for await (const event of model.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "Hi" }],
+                    },
+                ],
+                settings: {},
+            })) {
+                events.push(event);
+            }
+            // Check complete Message has metadata from end event
+            const messageEvent = events.find((e) => e.kind === "message");
+            expect(messageEvent).toMatchObject({
+                providerMetadata: { test: { version: "end" } }, // From end event, not start/delta
+            });
+        });
+        it("should pass through tool-call events unchanged", async () => {
+            const mockModel = {
+                provider: "test",
+                modelId: "test-model",
+                doStream: vi.fn().mockResolvedValue({
+                    stream: new ReadableStream({
+                        start(controller) {
+                            const parts = [
+                                {
+                                    type: "tool-call",
+                                    toolCallId: "call-123",
+                                    toolName: "calculator",
+                                    input: '{"expression":"2+2"}',
+                                    providerMetadata: undefined,
+                                },
+                                {
+                                    type: "finish",
+                                    finishReason: "tool-calls",
+                                    usage: {
+                                        inputTokens: 5,
+                                        outputTokens: 10,
+                                        totalTokens: 15,
+                                    },
+                                    providerMetadata: undefined,
+                                },
+                            ];
+                            for (const part of parts) {
+                                controller.enqueue(part);
+                            }
+                            controller.close();
+                        },
+                    }),
+                }),
+            };
+            const model = new AISDKLanguageModel(mockModel);
+            const events = [];
+            for await (const event of model.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [{ kind: "text", text: "Calculate 2+2" }],
+                    },
+                ],
+                settings: {},
+            })) {
+                events.push(event);
+            }
+            // Should have tool-call and finish
+            expect(events).toHaveLength(2);
+            expect(events[0]).toMatchObject({
+                kind: "tool-call",
+                callId: "call-123",
+                toolId: "calculator",
+                state: "completed",
+                arguments: '{"expression":"2+2"}',
+            });
+            expect(events[1]).toMatchObject({ kind: "finish" });
+        });
+    });
+});

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

@@ -204,7 +204,7 @@ describe("MESSAGE codec", () => {
                         type: "tool-call",
                         toolCallId: "call-123",
                         toolName: "get_weather",
-                        input: { city: "SF" },
+                        input: JSON.stringify({ city: "SF" }),
                         providerOptions: undefined,
                     },
                 ],

package/dist/convert/message.js

@@ -89,7 +89,7 @@ export const MESSAGE = {
                             type: "tool-call",
                             toolCallId: item.callId,
                             toolName: item.toolId,
-                            input: JSON.parse(item.arguments),
+                            input: item.arguments,
                             providerOptions: item.providerMetadata,
                         },
                     ],

package/dist/convert/response.js

@@ -34,7 +34,7 @@ export const MODEL_RESPONSE = {
                     callId: item.toolCallId,
                     toolId: item.toolName,
                     state: "completed",
-                    arguments: JSON.stringify(item.input),
+                    arguments: item.input,
                     providerMetadata: item.providerMetadata,
                 });
             }

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

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/convert/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAGlE;;GAEG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,cAAc,CAAC,yBAAyB,CAAC,GAChD,aAAa,CAAC,wBAAwB,CAAC,CAgBzC;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAC7B,wBAAwB,GAAG,IAAI,EAC/B,yBAAyB,CAoJ1B,CAAC"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/convert/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAIlE;;GAEG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,cAAc,CAAC,yBAAyB,CAAC,GAChD,aAAa,CAAC,wBAAwB,CAAC,CAgBzC;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAC7B,wBAAwB,GAAG,IAAI,EAC/B,yBAAyB,CAqJ1B,CAAC"}

package/dist/convert/stream.js

@@ -1,3 +1,4 @@
+import { COMPLETED, FAILED } from "@kernl-sdk/protocol";
 import { WARNING } from "./response";
 /**
  * Convert AI SDK stream to async iterable of kernl stream events.
@@ -90,8 +91,9 @@ export const STREAM_PART = {
             case "tool-call":
                 return {
                     kind: "tool-call",
-                    id: part.toolCallId,
-                    toolName: part.toolName,
+                    callId: part.toolCallId,
+                    toolId: part.toolName,
+                    state: COMPLETED,
                     arguments: part.input,
                     providerMetadata: part.providerMetadata,
                 };
@@ -101,7 +103,7 @@ export const STREAM_PART = {
                     kind: "tool-result",
                     callId: part.toolCallId,
                     toolId: part.toolName,
-                    state: part.isError ? "failed" : "completed",
+                    state: part.isError ? FAILED : COMPLETED,
                     result: part.result,
                     error: part.isError ? String(part.result) : null,
                     providerMetadata: part.providerMetadata,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @kernl-sdk/ai - AI SDK adapter for Kernl
+ * @kernl-sdk/ai - AI SDK adapter for kernl
  *
  * Universal provider support via Vercel AI SDK v5.
  *