kernl 0.2.0 → 0.6.0

package/.turbo/turbo-build.log

@@ -1,5 +1,4 @@
-
-
-> kernl@0.1.4 build /Users/andjones/Documents/projects/kernl/packages/kernl
-> tsc && tsc-alias
-
+
+> kernl@0.5.1 build /Users/andjones/Documents/projects/kernl/packages/kernl
+> tsc && tsc-alias
+

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

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

package/CHANGELOG.md

@@ -1,5 +1,152 @@
 # @kernl/core
 
+## 0.6.0
+
+### Minor 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.
+
+### Patch Changes
+
+- Updated dependencies
+  - @kernl-sdk/shared@0.1.5
+  - @kernl-sdk/protocol@0.2.4
+
+## 0.5.1
+
+### Patch Changes
+
+- 08ab8a0: Fix duplicate thread inserts when streaming from hydrated threads by making
+  storage-backed Thread instances explicitly marked as persisted, and ensure
+  Postgres integration tests cover the no-double-insert behavior.
+
+## 0.5.0
+
+### Minor Changes
+
+- ad56b86: Introduce the public Kernl threads API surface (`kernl.threads` and
+  `agent.threads`) for listing, getting, deleting, and reading history, backed
+  by simple `Thread` and `ThreadEvent` models.
+
+  Add explicit thread creation and update APIs, including first-class `title`
+  support (stored in `metadata.title`) and structured `context` / `metadata`
+  patch semantics, and tighten thread persistence behavior in core + storage
+  implementations to keep context and metadata consistent across in-memory and
+  Postgres stores.
+
+## 0.4.6
+
+### Patch Changes
+
+- Add PublicThreadEvent type to filter internal system events from client-facing APIs. ThreadResource.history and ThreadsResource.history() now return only public events (messages, tool calls, tool results), excluding internal system events.
+
+## 0.4.5
+
+### Patch Changes
+
+- 8e3bac1: Add ThreadResource public API type that separates the public thread interface from internal Thread execution primitive. ThreadsResource methods now return ThreadResource with serialized data instead of Thread class instances. Add createdAt/updatedAt timestamps to threads.
+
+## 0.4.4
+
+### Patch Changes
+
+- ba8119d: Fix Kernl type exports - remove duplicate old Kernl definition from dist root that was missing the threads property. The correct Kernl class with ThreadsResource is now properly exported.
+
+## 0.4.3
+
+### Patch Changes
+
+- f536b15: Add clean public API for thread management with ThreadsResource class and agent-scoped thread access. Users can now access threads via `kernl.threads.get/list/delete/history()` or use agent-scoped helpers like `agent.threads.list()` that automatically filter to that agent's threads.
+
+## 0.4.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @kernl-sdk/shared@0.1.4
+  - @kernl-sdk/protocol@0.2.3
+
+## 0.4.1
+
+### Patch Changes
+
+- feat: implement lazy storage initialization
+
+  Storage is now automatically initialized on first agent execution. The `ensureInitialized()` method is called internally by spawn/schedule methods, so users never have to manually call `storage.init()`. Initialization is idempotent and concurrency-safe.
+
+## 0.4.0
+
+### Minor Changes
+
+- feat: add storage infrastructure with automatic initialization
+
+  Adds comprehensive storage infrastructure to Kernl:
+  - New `KernlStorage` and `ThreadStore` interfaces for persistent thread management
+  - Automatic lazy initialization of storage on first agent execution
+  - Thread checkpointing at key lifecycle points (start, post-tools, terminal-tick, stop)
+  - Thread resumption support - pass `{ threadId }` to agent.run() or agent.stream()
+  - In-memory storage implementation as default (no setup required)
+  - PostgreSQL storage adapter via `@kernl/pg`
+  - LibSQL storage adapter via `@kernl/libsql`
+  - Full support for thread history queries and event filtering
+
+## 0.3.2
+
+### Patch Changes
+
+- fix: MCP tool schema compatibility with OpenAI
+
+  Fixed MCP tool parameter schema serialization to match AI SDK pattern. Empty-parameter MCP tools now generate schemas with `{ type: "object", properties: {}, additionalProperties: false }` which satisfies OpenAI's strict validation requirements.
+
+## 0.3.1
+
+### Patch Changes
+
+- e90f8bb: fix: handle model stream errors gracefully
+
+  Thread.stream() now properly catches and converts model errors (like missing API keys) to error events, preventing the UI from hanging. Errors are logged via logger.error() and sent to clients as error chunks.
+
+## 0.3.0
+
+### Minor Changes
+
+- Allow Agent.run() and Agent.stream() to accept LanguageModelItem[] as input
+  - Update run() and stream() methods to accept `string | LanguageModelItem[]`
+  - Convert string inputs to message items internally for backwards compatibility
+  - Enable passing decoded UI messages directly to agent methods for multi-turn conversations
+
+## 0.2.2
+
+### 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.2.1
+
+### Patch Changes
+
+- Minor bug fixes and improvements
+- Updated dependencies
+  - @kernl-sdk/protocol@0.2.1
+  - @kernl-sdk/shared@0.1.2
+
 ## 0.2.0
 
 ### Minor 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/agent/__tests__/concurrency.test.d.ts

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

package/dist/agent/__tests__/concurrency.test.d.ts.map

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

package/dist/agent/__tests__/concurrency.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from "vitest";
+import { Agent } from "../../agent";
+import { Kernl } from "../../kernl";
+import { createMockModel } from "../../thread/__tests__/fixtures/mock-model";
+import { RuntimeError } from "../../lib/error";
+import { message } from "@kernl-sdk/protocol";
+describe("Concurrent execution prevention", () => {
+    // (TODO): this should work
+    it.skip("should prevent two Agent.run() calls with same threadId", async () => {
+        const model = createMockModel(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            return {
+                content: [message({ role: "assistant", text: "Done" })],
+                finishReason: "stop",
+                usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+                warnings: [],
+            };
+        });
+        const agent = new Agent({
+            id: "test-agent",
+            name: "Test",
+            instructions: "Test",
+            model,
+        });
+        const kernl = new Kernl();
+        kernl.register(agent);
+        const tid = "concurrent-test-1";
+        // Start first run
+        const run1 = agent.run("First", { threadId: tid });
+        // Try second run immediately
+        await expect(agent.run("Second", { threadId: tid })).rejects.toThrow(RuntimeError);
+        await expect(agent.run("Second", { threadId: tid })).rejects.toThrow(/already running/);
+        // Wait for first to complete
+        await run1;
+        // Now third should work
+        await expect(agent.run("Third", { threadId: tid })).resolves.toBeDefined();
+    });
+    // (TODO): this should work
+    it.skip("should prevent Agent.stream() on thread already in Agent.run()", async () => {
+        const model = createMockModel(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            return {
+                content: [message({ role: "assistant", text: "Done" })],
+                finishReason: "stop",
+                usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+                warnings: [],
+            };
+        });
+        const agent = new Agent({
+            id: "test-agent",
+            name: "Test",
+            instructions: "Test",
+            model,
+        });
+        const kernl = new Kernl();
+        kernl.register(agent);
+        const tid = "concurrent-test-2";
+        // Start run()
+        const runPromise = agent.run("Test", { threadId: tid });
+        // Try to stream same thread
+        const streamIterable = agent.stream("Test", { threadId: tid });
+        const streamIterator = streamIterable[Symbol.asyncIterator]();
+        await expect(streamIterator.next()).rejects.toThrow(RuntimeError);
+        await expect(streamIterator.next()).rejects.toThrow(/already running/);
+        await runPromise;
+    });
+    it("should prevent Agent.run() on thread already in Agent.stream()", async () => {
+        const model = createMockModel(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            return {
+                content: [message({ role: "assistant", text: "Done" })],
+                finishReason: "stop",
+                usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+                warnings: [],
+            };
+        });
+        const agent = new Agent({
+            id: "test-agent",
+            name: "Test",
+            instructions: "Test",
+            model,
+        });
+        const kernl = new Kernl();
+        kernl.register(agent);
+        const tid = "concurrent-test-3";
+        // Start stream() but don't await - start consuming
+        const streamIterator = agent.stream("Test", { threadId: tid });
+        const streamPromise = (async () => {
+            for await (const _event of streamIterator) {
+                // consume
+            }
+        })();
+        // Give stream time to start
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Try to run() same thread
+        await expect(agent.run("Test", { threadId: tid })).rejects.toThrow(RuntimeError);
+        await streamPromise;
+    });
+    it("should allow different threadIds to run concurrently", async () => {
+        const model = createMockModel(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            return {
+                content: [message({ role: "assistant", text: "Done" })],
+                finishReason: "stop",
+                usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+                warnings: [],
+            };
+        });
+        const agent = new Agent({
+            id: "test-agent",
+            name: "Test",
+            instructions: "Test",
+            model,
+        });
+        const kernl = new Kernl();
+        kernl.register(agent);
+        // These should all succeed
+        const results = await Promise.all([
+            agent.run("Test 1", { threadId: "thread-1" }),
+            agent.run("Test 2", { threadId: "thread-2" }),
+            agent.run("Test 3", { threadId: "thread-3" }),
+        ]);
+        expect(results).toHaveLength(3);
+        expect(results.every((r) => r.response === "Done")).toBe(true);
+    });
+    it("should allow same threadId after previous run completes", async () => {
+        const model = createMockModel(async () => ({
+            content: [message({ role: "assistant", text: "Done" })],
+            finishReason: "stop",
+            usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+            warnings: [],
+        }));
+        const agent = new Agent({
+            id: "test-agent",
+            name: "Test",
+            instructions: "Test",
+            model,
+        });
+        const kernl = new Kernl();
+        kernl.register(agent);
+        const tid = "reuse-thread";
+        // First run
+        const result1 = await agent.run("First", { threadId: tid });
+        expect(result1.response).toBe("Done");
+        // Second run (should work since first completed)
+        const result2 = await agent.run("Second", { threadId: tid });
+        expect(result2.response).toBe("Done");
+        // Third run
+        const result3 = await agent.run("Third", { threadId: tid });
+        expect(result3.response).toBe("Done");
+    });
+});

package/dist/agent/__tests__/run.test.d.ts

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

package/dist/agent/__tests__/run.test.d.ts.map

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