@kernl-sdk/ai 0.1.2 → 0.2.5

package/.turbo/turbo-build.log

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

package/.turbo/turbo-check-types.log

@@ -0,0 +1,4 @@
+
+> @kernl-sdk/ai@0.1.4 check-types /Users/andjones/Documents/projects/kernl/packages/_ai
+> tsc --noEmit
+

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @kernl/ai
 
+## 0.2.5
+
+### Patch Changes
+
+- Migrate packages from GitHub Packages to npm registry.
+
+  **Breaking change for `kernl` (formerly `@kernl-sdk/core`):**
+
+  The core package has been renamed from `@kernl-sdk/core` to `kernl`. Update your imports:
+
+  ```diff
+  - import { Agent, Kernl } from "@kernl-sdk/core";
+  + import { Agent, Kernl } from "kernl";
+  ```
+
+  All other packages remain under the `@kernl-sdk` scope and are now publicly available on npm.
+
+- Updated dependencies
+  - @kernl-sdk/shared@0.1.5
+  - @kernl-sdk/protocol@0.2.4
+
+## 0.2.4
+
+### Patch Changes
+
+- 7946b16: Fix handling of tool calls with no required parameters. When AI providers (particularly Anthropic) send empty string arguments for tools with all optional parameters, convert to valid JSON "{}" to prevent parsing errors. Also fix tool-call state to use IN_PROGRESS instead of COMPLETED.
+
+## 0.2.3
+
+### Patch Changes
+
+- 8551086: Add historyToUIMessages function to convert thread history to AI SDK UIMessage format for useChat hook. Preserves providerMetadata on all parts (text, file, reasoning, tools) and groups tool calls with results.
+
+## 0.2.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @kernl-sdk/shared@0.1.4
+  - @kernl-sdk/protocol@0.2.3
+
+## 0.2.1
+
+### Patch Changes
+
+- 05ce1f1: fix: handle tool result errors with error-text output
+
+  When a tool call fails and returns an error, the MESSAGE codec now properly encodes the error using the AI SDK's error-text output type instead of attempting to send null as a json value. This fixes the "Missing required parameter: 'output'" error that occurred when MCP tools returned errors.
+
+## 0.2.0
+
+### Minor Changes
+
+- 0f25713: Add UI message and stream conversion utilities for AI SDK integration
+  - Add `UIMessageCodec` for bidirectional conversion between kernl and AI SDK message formats
+  - Add `toUIMessageStream()` helper to convert kernl streams to AI SDK UIMessageStream format
+  - Add `STREAM_UI_PART` codec for converting LanguageModelStreamEvent to UIMessageChunk
+  - Enable seamless integration with AI SDK's `useChat` hook and `createUIMessageStreamResponse`
+  - Add comprehensive test suites for both UI message and stream conversion
+
+## 0.1.4
+
+### Patch Changes
+
+- 2c62c0a: Migrate from @kernl to @kernl-sdk scope
+
+  All packages have been migrated to the @kernl-sdk scope for publishing to GitHub Packages under the kernl-sdk organization.
+
+- Updated dependencies [2c62c0a]
+  - @kernl-sdk/shared@0.1.3
+  - @kernl-sdk/protocol@0.2.2
+
+## 0.1.3
+
+### Patch Changes
+
+- 19020a1: Fix tool call argument encoding for multi-turn conversations with Anthropic models
+
 ## 0.1.2
 
 ### Patch Changes

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2025 Andrew Jones
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/__tests__/integration.test.js

@@ -1,23 +1,27 @@
 import { describe, it, expect, beforeAll } from "vitest";
 import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { IN_PROGRESS } from "@kernl-sdk/protocol";
 import { AISDKLanguageModel } from "../language-model";
 /**
  * Integration tests for AISDKLanguageModel with real AI SDK providers.
  *
- * These tests require an OPENAI_API_KEY environment variable to be set.
- * They will be skipped if the API key is not available.
+ * These tests require API keys to be set:
+ * - OPENAI_API_KEY for OpenAI tests
+ * - ANTHROPIC_API_KEY for Anthropic tests
  *
- * Run with: OPENAI_API_KEY=your-key pnpm test:run
+ * Run with: OPENAI_API_KEY=your-key ANTHROPIC_API_KEY=your-key pnpm test:run
  */
-const SKIP_INTEGRATION_TESTS = !process.env.OPENAI_API_KEY;
-describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () => {
-    let gpt4omini;
+const SKIP_OPENAI_TESTS = !process.env.OPENAI_API_KEY;
+const SKIP_ANTHROPIC_TESTS = !process.env.ANTHROPIC_API_KEY;
+describe.skipIf(SKIP_OPENAI_TESTS)("AISDKLanguageModel - OpenAI", () => {
+    let gpt41;
     beforeAll(() => {
-        gpt4omini = new AISDKLanguageModel(openai("gpt-4o-mini")); // gpt-4o-mini for fast, cheap testing
+        gpt41 = new AISDKLanguageModel(openai("gpt-4.1"));
     });
     describe("generate", () => {
         it("should generate a simple text response", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -44,7 +48,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(messages.length).toBeGreaterThan(0);
         });
         it("should handle system messages", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -73,7 +77,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(response.usage.totalTokens).toBeGreaterThan(0);
         });
         it("should handle multi-turn conversations", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -106,7 +110,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(assistantMessages.length).toBeGreaterThan(0);
         });
         it("should respect temperature setting", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -124,7 +128,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(response.usage.totalTokens).toBeGreaterThan(0);
         });
         it("should respect maxTokens setting", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -146,7 +150,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
     describe("stream", () => {
         it("should stream text responses", async () => {
             const events = [];
-            for await (const event of gpt4omini.stream({
+            for await (const event of gpt41.stream({
                 input: [
                     {
                         kind: "message",
@@ -173,7 +177,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
         it("should stream text deltas", async () => {
             const events = [];
-            for await (const event of gpt4omini.stream({
+            for await (const event of gpt41.stream({
                 input: [
                     {
                         kind: "message",
@@ -200,7 +204,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
         it("should handle limited token streams", async () => {
             const events = [];
-            for await (const event of gpt4omini.stream({
+            for await (const event of gpt41.stream({
                 input: [
                     {
                         kind: "message",
@@ -223,7 +227,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
         it("should yield both delta events and complete Message items", async () => {
             const events = [];
-            for await (const event of gpt4omini.stream({
+            for await (const event of gpt41.stream({
                 input: [
                     {
                         kind: "message",
@@ -264,18 +268,75 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(textContent.text).toBeDefined();
             expect(textContent.text.length).toBeGreaterThan(0);
             // Verify accumulated text matches concatenated deltas
-            const accumulatedFromDeltas = textDeltas
-                .map((d) => d.text)
-                .join("");
+            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);
         });
+        it("should handle streaming tools with no required parameters (empty arguments)", async () => {
+            // Verify the empty arguments fix works in streaming mode as well
+            const events = [];
+            for await (const event of gpt41.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [
+                            {
+                                kind: "text",
+                                text: "Use the list_all_items tool",
+                            },
+                        ],
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "list_all_items",
+                        description: "List all items",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                category: {
+                                    type: "string",
+                                    description: "Optional category filter",
+                                },
+                            },
+                            // No required parameters
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                    toolChoice: { kind: "required" }, // Force tool use
+                },
+            })) {
+                events.push(event);
+            }
+            expect(events.length).toBeGreaterThan(0);
+            // Should have a tool-call event
+            const toolCalls = events.filter((e) => e.kind === "tool-call");
+            expect(toolCalls.length).toBeGreaterThan(0);
+            const toolCall = toolCalls[0];
+            expect(toolCall.callId).toBeDefined();
+            expect(toolCall.toolId).toBe("list_all_items");
+            expect(toolCall.state).toBe(IN_PROGRESS);
+            // Critical assertion: arguments should be valid JSON even if empty
+            expect(toolCall.arguments).toBeDefined();
+            expect(() => JSON.parse(toolCall.arguments)).not.toThrow();
+            const args = JSON.parse(toolCall.arguments);
+            expect(typeof args).toBe("object");
+            // 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 () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -317,7 +378,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(toolCall.arguments).toBeDefined();
         });
         it("should handle tool choice setting", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -360,7 +421,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(toolCalls.length).toBeGreaterThan(0);
         });
         it("should handle multiple tool calls", async () => {
-            const response = await gpt4omini.generate({
+            const response = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -403,7 +464,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
         it("should handle multi-turn conversation with tool results", async () => {
             // First turn: get tool calls from the model
-            const firstResponse = await gpt4omini.generate({
+            const firstResponse = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -442,7 +503,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             expect(toolCall.callId).toBeDefined();
             expect(toolCall.toolId).toBe("calculate");
             // Second turn: send tool results back to the model
-            const secondResponse = await gpt4omini.generate({
+            const secondResponse = await gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -487,11 +548,73 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
             const messages = secondResponse.content.filter((item) => item.kind === "message" && item.role === "assistant");
             expect(messages.length).toBeGreaterThan(0);
         });
+        it("should handle tools with no required parameters (empty arguments)", async () => {
+            // This test verifies the fix for empty string arguments
+            // When a tool has no required parameters and is called with no args,
+            // AI SDK sends input: "", which should be converted to "{}" for valid JSON
+            const response = await gpt41.generate({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [
+                            {
+                                kind: "text",
+                                text: "Use the list_issues tool to get all issues",
+                            },
+                        ],
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "list_issues",
+                        description: "List all issues in the system",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                status: {
+                                    type: "string",
+                                    description: "Optional status filter",
+                                    enum: ["open", "closed", "all"],
+                                },
+                                limit: {
+                                    type: "number",
+                                    description: "Optional limit on number of results",
+                                },
+                            },
+                            // No required parameters - all are optional
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                    toolChoice: { kind: "required" }, // Force tool use
+                },
+            });
+            expect(response.content).toBeDefined();
+            // Should have a tool call
+            const toolCalls = response.content.filter((item) => item.kind === "tool-call");
+            expect(toolCalls.length).toBeGreaterThan(0);
+            const toolCall = toolCalls[0];
+            expect(toolCall.callId).toBeDefined();
+            expect(toolCall.toolId).toBe("list_issues");
+            expect(toolCall.state).toBe(IN_PROGRESS);
+            // The critical assertion: arguments should be valid JSON
+            // Even if the tool was called with no args, it should be "{}" not ""
+            expect(toolCall.arguments).toBeDefined();
+            expect(() => JSON.parse(toolCall.arguments)).not.toThrow();
+            // Parse should succeed and yield an object (possibly empty)
+            const args = JSON.parse(toolCall.arguments);
+            expect(typeof args).toBe("object");
+        });
     });
     describe("validation", () => {
         it("should throw error for invalid maxTokens", async () => {
             // AI SDK properly validates and throws errors for invalid values
-            await expect(gpt4omini.generate({
+            await expect(gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -507,7 +630,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
         it("should throw error for below minimum maxTokens", async () => {
             // OpenAI requires minimum 16 tokens
-            await expect(gpt4omini.generate({
+            await expect(gpt41.generate({
                 input: [
                     {
                         kind: "message",
@@ -523,3 +646,131 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("AISDKLanguageModel integration", () =>
         });
     });
 });
+describe.skipIf(SKIP_ANTHROPIC_TESTS)("AISDKLanguageModel - Anthropic", () => {
+    let claude;
+    beforeAll(() => {
+        claude = new AISDKLanguageModel(anthropic("claude-sonnet-4-5"));
+    });
+    describe("tools", () => {
+        it("should handle tools with no required parameters (Anthropic-specific)", async () => {
+            // This test specifically verifies Anthropic's behavior with empty arguments
+            // Anthropic was the provider that sent input: "" for tools with no required params
+            const response = await claude.generate({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [
+                            {
+                                kind: "text",
+                                text: "Use the list_issues tool",
+                            },
+                        ],
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "list_issues",
+                        description: "List all issues in the system",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                status: {
+                                    type: "string",
+                                    description: "Optional status filter",
+                                    enum: ["open", "closed", "all"],
+                                },
+                                assignee: {
+                                    type: "string",
+                                    description: "Optional assignee filter",
+                                },
+                            },
+                            // No required parameters - all are optional
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                    toolChoice: { kind: "required" }, // Force tool use
+                },
+            });
+            expect(response.content).toBeDefined();
+            // Should have a tool call
+            const toolCalls = response.content.filter((item) => item.kind === "tool-call");
+            expect(toolCalls.length).toBeGreaterThan(0);
+            const toolCall = toolCalls[0];
+            expect(toolCall.callId).toBeDefined();
+            expect(toolCall.toolId).toBe("list_issues");
+            expect(toolCall.state).toBe(IN_PROGRESS);
+            // Critical: Anthropic sends input: "" for tools with no required params
+            // Our adapter must convert this to "{}" for valid JSON
+            expect(toolCall.arguments).toBeDefined();
+            expect(() => JSON.parse(toolCall.arguments)).not.toThrow();
+            const args = JSON.parse(toolCall.arguments);
+            expect(typeof args).toBe("object");
+        });
+        it("should handle streaming tools with no required parameters (Anthropic-specific)", async () => {
+            // Verify the fix works in streaming mode with Anthropic
+            const events = [];
+            for await (const event of claude.stream({
+                input: [
+                    {
+                        kind: "message",
+                        role: "user",
+                        id: "msg-1",
+                        content: [
+                            {
+                                kind: "text",
+                                text: "Use the get_all_data tool",
+                            },
+                        ],
+                    },
+                ],
+                tools: [
+                    {
+                        kind: "function",
+                        name: "get_all_data",
+                        description: "Get all data from the system",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                format: {
+                                    type: "string",
+                                    description: "Optional output format",
+                                    enum: ["json", "csv", "xml"],
+                                },
+                            },
+                            // No required parameters
+                        },
+                    },
+                ],
+                settings: {
+                    maxTokens: 200,
+                    temperature: 0,
+                    toolChoice: { kind: "required" }, // Force tool use
+                },
+            })) {
+                events.push(event);
+            }
+            expect(events.length).toBeGreaterThan(0);
+            // Should have a tool-call event
+            const toolCalls = events.filter((e) => e.kind === "tool-call");
+            expect(toolCalls.length).toBeGreaterThan(0);
+            const toolCall = toolCalls[0];
+            expect(toolCall.callId).toBeDefined();
+            expect(toolCall.toolId).toBe("get_all_data");
+            expect(toolCall.state).toBe(IN_PROGRESS);
+            // Critical: arguments should be valid JSON even if Anthropic sent ""
+            expect(toolCall.arguments).toBeDefined();
+            expect(() => JSON.parse(toolCall.arguments)).not.toThrow();
+            const args = JSON.parse(toolCall.arguments);
+            expect(typeof args).toBe("object");
+            // Should have finish event
+            const finishEvents = events.filter((e) => e.kind === "finish");
+            expect(finishEvents.length).toBe(1);
+        });
+    });
+});

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

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
+import { IN_PROGRESS } from "@kernl-sdk/protocol";
 import { AISDKLanguageModel } from "../language-model";
 /**
  * Unit tests for AISDKLanguageModel stream accumulation behavior
@@ -414,7 +415,7 @@ describe("AISDKLanguageModel", () => {
                 kind: "tool-call",
                 callId: "call-123",
                 toolId: "calculator",
-                state: "completed",
+                state: IN_PROGRESS,
                 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: JSON.stringify({ city: "SF" }),
+                        input: { city: "SF" },
                         providerOptions: undefined,
                     },
                 ],
@@ -251,6 +251,31 @@ describe("MESSAGE codec", () => {
                 ],
             });
         });
+        it("should encode tool-result item with error", () => {
+            const result = MESSAGE.encode({
+                kind: "tool-result",
+                callId: "call-123",
+                toolId: "get_weather",
+                state: "failed",
+                result: null,
+                error: "Network timeout",
+            });
+            expect(result).toEqual({
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call-123",
+                        toolName: "get_weather",
+                        output: {
+                            type: "error-text",
+                            value: "Network timeout",
+                        },
+                        providerOptions: undefined,
+                    },
+                ],
+            });
+        });
     });
     describe("encode - reasoning items", () => {
         it("should encode reasoning item with text", () => {
@@ -289,7 +314,7 @@ describe("MESSAGE codec", () => {
         it("should throw error for unsupported item kind", () => {
             expect(() => MESSAGE.encode({
                 kind: "unknown-kind",
-            })).toThrow("Unsupported LanguageModelItem kind: unknown-kind");
+            })).toThrow("Unsupported LanguageModelItem kind");
         });
     });
     describe("decode", () => {