@kernl-sdk/ai 0.1.1 → 0.1.2

package/src/__tests__/language-model.test.ts

@@ -0,0 +1,465 @@
+import { describe, it, expect, vi } from "vitest";
+import type {
+  LanguageModelV3,
+  LanguageModelV3StreamPart,
+} from "@ai-sdk/provider";
+
+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: LanguageModelV3 = {
+        provider: "test",
+        modelId: "test-model",
+        doStream: vi.fn().mockResolvedValue({
+          stream: new ReadableStream({
+            start(controller) {
+              const parts: LanguageModelV3StreamPart[] = [
+                {
+                  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();
+            },
+          }),
+        }),
+      } as any;
+
+      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: LanguageModelV3 = {
+        provider: "test",
+        modelId: "test-model",
+        doStream: vi.fn().mockResolvedValue({
+          stream: new ReadableStream({
+            start(controller) {
+              const parts: LanguageModelV3StreamPart[] = [
+                {
+                  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();
+            },
+          }),
+        }),
+      } as any;
+
+      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: LanguageModelV3 = {
+        provider: "test",
+        modelId: "test-model",
+        doStream: vi.fn().mockResolvedValue({
+          stream: new ReadableStream({
+            start(controller) {
+              const parts: LanguageModelV3StreamPart[] = [
+                { 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();
+            },
+          }),
+        }),
+      } as any;
+
+      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: LanguageModelV3 = {
+        provider: "test",
+        modelId: "test-model",
+        doStream: vi.fn().mockResolvedValue({
+          stream: new ReadableStream({
+            start(controller) {
+              const parts: LanguageModelV3StreamPart[] = [
+                {
+                  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();
+            },
+          }),
+        }),
+      } as any;
+
+      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: LanguageModelV3 = {
+        provider: "test",
+        modelId: "test-model",
+        doStream: vi.fn().mockResolvedValue({
+          stream: new ReadableStream({
+            start(controller) {
+              const parts: LanguageModelV3StreamPart[] = [
+                {
+                  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();
+            },
+          }),
+        }),
+      } as any;
+
+      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/src/convert/__tests__/message.test.ts

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

package/src/convert/message.ts

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

package/src/convert/response.ts

@@ -62,7 +62,7 @@ export const MODEL_RESPONSE: Codec<LanguageModelResponse, AISdkGenerateResult> =
             callId: item.toolCallId,
             toolId: item.toolName,
             state: "completed",
-            arguments: JSON.stringify(item.input),
+            arguments: item.input,
             providerMetadata: item.providerMetadata,
           });
         } else if (item.type === "file") {

package/src/convert/stream.ts

@@ -1,5 +1,6 @@
 import type { Codec, LanguageModelStreamEvent } from "@kernl-sdk/protocol";
 import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import { COMPLETED, FAILED } from "@kernl-sdk/protocol";
 import { WARNING } from "./response";
 
 /**
@@ -109,8 +110,9 @@ export const STREAM_PART: Codec<
       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,
         };
@@ -121,7 +123,7 @@ export const STREAM_PART: Codec<
           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/src/index.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.
  *

package/src/language-model.ts

@@ -6,6 +6,7 @@ import type {
   LanguageModelResponse,
   LanguageModelStreamEvent,
 } from "@kernl-sdk/protocol";
+import { message, reasoning } from "@kernl-sdk/protocol";
 
 import { MESSAGE } from "./convert/message";
 import { TOOL } from "./convert/tools";
@@ -69,7 +70,73 @@ export class AISDKLanguageModel implements LanguageModel {
         abortSignal: request.abort,
       });
 
-      yield* convertStream(stream.stream);
+      // text and reasoning buffers for delta accumulation
+      const tbuf: Record<string, string> = {};
+      const rbuf: Record<string, string> = {};
+
+      for await (const event of convertStream(stream.stream)) {
+        switch (event.kind) {
+          case "text-start": {
+            tbuf[event.id] = "";
+            yield event;
+            break;
+          }
+
+          case "text-delta": {
+            if (tbuf[event.id] !== undefined) {
+              tbuf[event.id] += event.text;
+            }
+            yield event;
+            break;
+          }
+
+          case "text-end": {
+            const text = tbuf[event.id];
+            if (text !== undefined) {
+              yield message({
+                role: "assistant",
+                text,
+                providerMetadata: event.providerMetadata,
+              });
+              delete tbuf[event.id];
+            }
+            yield event;
+            break;
+          }
+
+          case "reasoning-start": {
+            rbuf[event.id] = "";
+            yield event;
+            break;
+          }
+
+          case "reasoning-delta": {
+            if (rbuf[event.id] !== undefined) {
+              rbuf[event.id] += event.text;
+            }
+            yield event;
+            break;
+          }
+
+          case "reasoning-end": {
+            const text = rbuf[event.id];
+            if (text !== undefined) {
+              yield reasoning({
+                text,
+                providerMetadata: event.providerMetadata,
+              });
+              delete rbuf[event.id];
+            }
+            yield event;
+            break;
+          }
+
+          default:
+            // all other events (tool-call, tool-result, finish, etc.) pass through
+            yield event;
+            break;
+        }
+      }
     } catch (error) {
       throw wrapError(error, "stream");
     }

package/src/providers/anthropic.ts

@@ -2,7 +2,7 @@ import { anthropic as createAnthropicModel } from "@ai-sdk/anthropic";
 import { AISDKLanguageModel } from "../language-model";
 
 /**
- * Create a Kernl-compatible Anthropic language model.
+ * Create a kernl-compatible Anthropic language model.
  *
  * @example
  * ```ts

package/src/providers/google.ts

@@ -2,7 +2,7 @@ import { google as createGoogleModel } from "@ai-sdk/google";
 import { AISDKLanguageModel } from "../language-model";
 
 /**
- * Create a Kernl-compatible Google Generative AI language model.
+ * Create a kernl-compatible Google Generative AI language model.
  *
  * @example
  * ```ts

package/src/providers/openai.ts

@@ -2,7 +2,7 @@ import { openai as createOpenAIModel } from "@ai-sdk/openai";
 import { AISDKLanguageModel } from "../language-model";
 
 /**
- * Create a Kernl-compatible OpenAI language model.
+ * Create a kernl-compatible OpenAI language model.
  *
  * @example
  * ```ts