kernl 0.2.0 → 0.6.0

package/src/thread/__tests__/integration.test.ts

@@ -10,6 +10,7 @@ import { tool, Toolkit } from "@/tool";
 import { Thread } from "../thread";
 
 import type { ThreadEvent, ThreadStreamEvent } from "@/types/thread";
+import type { LanguageModelItem } from "@kernl-sdk/protocol";
 
 /**
  * Integration tests for Thread streaming with real AI SDK providers.
@@ -44,7 +45,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         model,
       });
 
-      const input: ThreadEvent[] = [
+      const input: LanguageModelItem[] = [
         {
           kind: "message",
           id: "msg-1",
@@ -55,7 +56,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
       ];
 
-      const thread = new Thread(kernl, agent, input);
+      const thread = new Thread({ agent, input });
       const events = [];
 
       for await (const event of thread.stream()) {
@@ -116,7 +117,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         model,
       });
 
-      const input: ThreadEvent[] = [
+      const input: LanguageModelItem[] = [
         {
           kind: "message",
           id: "msg-1",
@@ -125,7 +126,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
       ];
 
-      const thread = new Thread(kernl, agent, input);
+      const thread = new Thread({ agent, input });
       const streamEvents = [];
 
       for await (const event of thread.stream()) {
@@ -200,7 +201,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         toolkits: [toolkit],
       });
 
-      const input: ThreadEvent[] = [
+      const input: LanguageModelItem[] = [
         {
           kind: "message",
           id: "msg-1",
@@ -209,7 +210,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
       ];
 
-      const thread = new Thread(kernl, agent, input);
+      const thread = new Thread({ agent, input });
       const events: ThreadStreamEvent[] = [];
 
       for await (const event of thread.stream()) {
@@ -266,6 +267,106 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
         30000,
       );
+
+      it(
+        "should properly encode tool results with matching callIds for multi-turn",
+        async () => {
+          const multiplyTool = tool({
+            id: "multiply",
+            name: "multiply",
+            description: "Multiply two numbers",
+            parameters: z.object({
+              a: z.number().describe("First number"),
+              b: z.number().describe("Second number"),
+            }),
+            execute: async (ctx, { a, b }) => {
+              return a * b;
+            },
+          });
+
+          const toolkit = new Toolkit({
+            id: "math",
+            tools: [multiplyTool],
+          });
+
+          const agent = new Agent({
+            id: "test-multi-turn",
+            name: "Test Multi-Turn Agent",
+            instructions: "You are a helpful assistant that can do math.",
+            model,
+            toolkits: [toolkit],
+          });
+
+          const input: LanguageModelItem[] = [
+            {
+              kind: "message",
+              id: "msg-1",
+              role: "user",
+              content: [{ kind: "text", text: "What is 7 times 6?" }],
+            },
+          ];
+
+          const thread = new Thread({ agent, input });
+          const events: ThreadStreamEvent[] = [];
+
+          // Collect all events from the stream
+          for await (const event of thread.stream()) {
+            events.push(event);
+          }
+
+          // Find the tool call and result
+          const toolCalls = events.filter(
+            (e): e is Extract<ThreadStreamEvent, { kind: "tool-call" }> =>
+              e.kind === "tool-call",
+          );
+          const toolResults = events.filter(
+            (e): e is Extract<ThreadStreamEvent, { kind: "tool-result" }> =>
+              e.kind === "tool-result",
+          );
+
+          expect(toolCalls.length).toBeGreaterThan(0);
+          expect(toolResults.length).toBeGreaterThan(0);
+
+          const multiplyCall = toolCalls[0];
+          const multiplyResult = toolResults[0];
+
+          // Verify callId matches between tool call and result
+          expect(multiplyCall.callId).toBe(multiplyResult.callId);
+          expect(multiplyCall.toolId).toBe("multiply");
+          expect(multiplyResult.toolId).toBe("multiply");
+
+          // Verify the tool result has the correct structure
+          expect(multiplyResult.callId).toBeDefined();
+          expect(typeof multiplyResult.callId).toBe("string");
+          expect(multiplyResult.callId.length).toBeGreaterThan(0);
+
+          // Verify history contains both with matching callIds
+          const history = (thread as any).history as ThreadEvent[];
+          const historyToolCall = history.find(
+            (e) => e.kind === "tool-call" && e.toolId === "multiply",
+          );
+          const historyToolResult = history.find(
+            (e) => e.kind === "tool-result" && e.toolId === "multiply",
+          );
+
+          expect(historyToolCall).toBeDefined();
+          expect(historyToolResult).toBeDefined();
+          expect((historyToolCall as any).callId).toBe(
+            (historyToolResult as any).callId,
+          );
+
+          // Verify final response uses the tool result
+          const messages = events.filter((e) => e.kind === "message");
+          const assistantMessage = messages.find((m: any) => m.role === "assistant");
+          expect(assistantMessage).toBeDefined();
+          const textContent = (assistantMessage as any).content.find(
+            (c: any) => c.kind === "text",
+          );
+          expect(textContent).toBeDefined();
+          expect(textContent.text).toContain("42");
+        },
+        30000,
+      );
     });
 
     describe("execute()", () => {
@@ -279,7 +380,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         model,
       });
 
-      const input: ThreadEvent[] = [
+      const input: LanguageModelItem[] = [
         {
           kind: "message",
           id: "msg-1",
@@ -288,7 +389,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
       ];
 
-      const thread = new Thread(kernl, agent, input);
+      const thread = new Thread({ agent, input });
       const result = await thread.execute();
 
       // Should have a response
@@ -319,7 +420,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         responseType: responseSchema,
       });
 
-      const input: ThreadEvent[] = [
+      const input: LanguageModelItem[] = [
         {
           kind: "message",
           id: "msg-1",
@@ -333,7 +434,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)(
         },
       ];
 
-      const thread = new Thread(kernl, agent, input);
+      const thread = new Thread({ agent, input });
       const result = await thread.execute();
 
       // Response should be validated and parsed

package/src/thread/__tests__/namespace.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from "vitest";
+
+import { Thread } from "../thread";
+import { Agent } from "@/agent";
+import { Kernl } from "@/kernl";
+import { Context } from "@/context";
+import { InMemoryStorage } from "@/storage/in-memory";
+import { createMockModel } from "./fixtures/mock-model";
+import type { LanguageModelRequest, LanguageModelItem } from "@kernl-sdk/protocol";
+
+// Helper to create user message input
+function userMessage(text: string): LanguageModelItem[] {
+  return [
+    {
+      kind: "message" as const,
+      id: "msg-test",
+      role: "user" as const,
+      content: [{ kind: "text" as const, text }],
+    },
+  ];
+}
+
+describe("Thread Namespaces", () => {
+  it("should use 'kernl' namespace by default", () => {
+    const model = createMockModel(async () => ({
+      content: [],
+      finishReason: "stop",
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      warnings: [],
+    }));
+
+    const agent = new Agent({
+      id: "test",
+      name: "Test",
+      instructions: "Test agent",
+      model,
+    });
+
+    const thread = new Thread({ agent });
+
+    expect(thread.namespace).toBe("kernl");
+    expect(thread.context.namespace).toBe("kernl");
+  });
+
+  it("should accept custom namespace in constructor", () => {
+    const model = createMockModel(async () => ({
+      content: [],
+      finishReason: "stop",
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      warnings: [],
+    }));
+
+    const agent = new Agent({
+      id: "test",
+      name: "Test",
+      instructions: "Test agent",
+      model,
+    });
+
+    const thread = new Thread({
+      agent,
+      namespace: "tenant-123",
+    });
+
+    expect(thread.namespace).toBe("tenant-123");
+    expect(thread.context.namespace).toBe("tenant-123");
+  });
+
+  it("should propagate namespace from agent.run() options", async () => {
+    const model = createMockModel(async (req: LanguageModelRequest) => {
+      return {
+        content: [
+          {
+            kind: "message" as const,
+            id: "msg_1",
+            role: "assistant" as const,
+            content: [{ kind: "text" as const, text: "Hello" }],
+          },
+        ],
+        finishReason: "stop",
+        usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+        warnings: [],
+      };
+    });
+
+    const agent = new Agent({
+      id: "test",
+      name: "Test",
+      instructions: "Test agent",
+      model,
+    });
+
+    // Mock storage to intercept the thread creation
+    const storage = new InMemoryStorage();
+    const kernl = new Kernl({ storage: { db: storage } });
+    kernl.register(agent);
+
+    const result = await agent.run("Hello", {
+      namespace: "custom-ns",
+    });
+
+    // Verify storage persistence
+    const threads = await storage.threads.list();
+    const persistedThread = threads[0];
+    
+    expect(persistedThread).toBeDefined();
+    expect(persistedThread.namespace).toBe("custom-ns");
+    expect(persistedThread.context.namespace).toBe("custom-ns");
+  });
+
+  it("should filter threads by namespace in storage", async () => {
+    const model = createMockModel(async () => ({
+      content: [
+        {
+          kind: "message" as const,
+          id: "msg_ok",
+          role: "assistant" as const,
+          content: [{ kind: "text" as const, text: "ok" }],
+        },
+      ],
+      finishReason: "stop",
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      warnings: [],
+    }));
+
+    const agent = new Agent({
+      id: "test",
+      name: "Test",
+      instructions: "Test agent",
+      model,
+    });
+
+    const storage = new InMemoryStorage();
+    const kernl = new Kernl({ storage: { db: storage } });
+    kernl.register(agent);
+
+    // Create threads in different namespaces
+    await agent.run("Thread 1", { namespace: "ns-a" });
+    await agent.run("Thread 2", { namespace: "ns-b" });
+    await agent.run("Thread 3", { namespace: "ns-a" });
+
+    // Verify filtering
+    const nsAThreads = await storage.threads.list({
+      filter: { namespace: "ns-a" },
+    });
+    
+    expect(nsAThreads).toHaveLength(2);
+    expect(nsAThreads.every(t => t.namespace === "ns-a")).toBe(true);
+
+    const nsBThreads = await storage.threads.list({
+      filter: { namespace: "ns-b" },
+    });
+
+    expect(nsBThreads).toHaveLength(1);
+    expect(nsBThreads[0].namespace).toBe("ns-b");
+  });
+});
+