kernl 0.1.3 → 0.2.0

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { z } from "zod";
 
-import type { LanguageModel, LanguageModelRequest } from "@kernl-sdk/protocol";
+import type { LanguageModelRequest } from "@kernl-sdk/protocol";
 import { IN_PROGRESS, COMPLETED, FAILED } from "@kernl-sdk/protocol";
 
 import { Thread } from "../thread";
@@ -12,37 +12,42 @@ import { tool, FunctionToolkit } from "@/tool";
 import { ModelBehaviorError } from "@/lib/error";
 
 import type { ThreadEvent } from "@/types/thread";
+import { createMockModel } from "./fixtures/mock-model";
+
+// Helper to create user message input
+function userMessage(text: string): ThreadEvent[] {
+  return [
+    {
+      kind: "message" as const,
+      id: "msg-test",
+      role: "user" as const,
+      content: [{ kind: "text" as const, text }],
+    },
+  ];
+}
 
 describe("Thread", () => {
   describe("Basic Execution", () => {
     it("should execute single turn and terminate with exact history", async () => {
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Hello world" }],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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 world" }],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -52,7 +57,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "Hello world");
+      const thread = new Thread(kernl, agent, userMessage("Hello world"));
 
       const result = await thread.execute();
 
@@ -74,38 +79,29 @@ describe("Thread", () => {
         },
       ]);
 
-      expect(result.state.tick).toBe(1);
-      expect(result.state.modelResponses).toHaveLength(1);
+      expect(thread._tick).toBe(1);
     });
 
     it("should convert string input to UserMessage", async () => {
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Response" }],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: "Response" }],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -115,7 +111,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "Test input");
+      const thread = new Thread(kernl, agent, userMessage("Test input"));
 
       await thread.execute();
 
@@ -131,33 +127,25 @@ describe("Thread", () => {
     });
 
     it("should use array input as-is", async () => {
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Response" }],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: "Response" }],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -191,64 +179,56 @@ describe("Thread", () => {
     it("should execute multi-turn with tool call and exact history", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
-
-          // First call: return tool call
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "echo",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: JSON.stringify({ text: "test" }),
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // Second call: return final message
+        // First call: return tool call
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done!" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "echo",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: JSON.stringify({ text: "test" }),
               },
             ],
             finishReason: "stop",
             usage: {
-              inputTokens: 4,
+              inputTokens: 2,
               outputTokens: 2,
-              totalTokens: 6,
+              totalTokens: 4,
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return final message
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done!" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 4,
+            outputTokens: 2,
+            totalTokens: 6,
+          },
+          warnings: [],
+        };
+      });
 
       const echoTool = tool({
         id: "echo",
@@ -268,7 +248,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "Use the echo tool");
+      const thread = new Thread(kernl, agent, userMessage("Use the echo tool"));
 
       const result = await thread.execute();
 
@@ -292,16 +272,16 @@ describe("Thread", () => {
         // Tool call (tick 1)
         {
           kind: "tool-call",
-          id: "echo",
+          toolId: "echo",
           callId: "call_1",
-          name: "echo",
+          state: IN_PROGRESS,
           arguments: JSON.stringify({ text: "test" }),
         },
         // Tool result (executed after tick 1)
         {
           kind: "tool-result",
           callId: "call_1",
-          name: "echo",
+          toolId: "echo",
           state: COMPLETED,
           result: "Echo: test",
           error: null,
@@ -315,96 +295,87 @@ describe("Thread", () => {
         },
       ]);
 
-      expect(result.state.tick).toBe(2);
-      expect(result.state.modelResponses).toHaveLength(2);
+      expect(thread._tick).toBe(2);
     });
 
     it("should accumulate history across multiple turns", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "simple",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: "first",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
+        if (callCount === 1) {
+          return {
+            content: [
+              {
+                kind: "message" as const,
+                id: "msg_1",
+                role: "assistant" as const,
+                content: [],
               },
-              warnings: [],
-            };
-          }
-
-          if (callCount === 2) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_2",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "simple",
-                  state: IN_PROGRESS,
-                  callId: "call_2",
-                  arguments: "second",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 3,
-                outputTokens: 2,
-                totalTokens: 5,
+              {
+                kind: "tool-call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "first",
               },
-              warnings: [],
-            };
-          }
+            ],
+            finishReason: "stop",
+            usage: {
+              inputTokens: 2,
+              outputTokens: 2,
+              totalTokens: 4,
+            },
+            warnings: [],
+          };
+        }
 
+        if (callCount === 2) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_3",
+                id: "msg_2",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "All done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: "call_2",
+                arguments: "second",
               },
             ],
             finishReason: "stop",
             usage: {
-              inputTokens: 4,
+              inputTokens: 3,
               outputTokens: 2,
-              totalTokens: 6,
+              totalTokens: 5,
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_3",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "All done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 4,
+            outputTokens: 2,
+            totalTokens: 6,
+          },
+          warnings: [],
+        };
+      });
 
       const simpleTool = tool({
         id: "simple",
@@ -424,7 +395,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "Start");
+      const thread = new Thread(kernl, agent, userMessage("Start"));
 
       const result = await thread.execute();
 
@@ -432,7 +403,7 @@ describe("Thread", () => {
 
       // Should have: 1 user msg + 3 assistant msgs + 2 tool calls + 2 tool results = 8 events
       expect(history).toHaveLength(8);
-      expect(result.state.tick).toBe(3);
+      expect(thread._tick).toBe(3);
     });
   });
 
@@ -440,49 +411,25 @@ describe("Thread", () => {
     it("should handle tool not found with exact error in history", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // First call: return tool call
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "nonexistent",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: "{}",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
-
-          // Second call: return terminal message
+        // First call: return tool call
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "nonexistent",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "{}",
               },
             ],
             finishReason: "stop",
@@ -493,11 +440,27 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return terminal message
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -508,7 +471,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await thread.execute();
 
@@ -529,49 +492,25 @@ describe("Thread", () => {
     it("should handle tool execution error", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // First call: return tool call
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "failing",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: "{}",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
-
-          // Second call: return terminal message
+        // First call: return tool call
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "failing",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "{}",
               },
             ],
             finishReason: "stop",
@@ -582,11 +521,27 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return terminal message
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const failingTool = tool({
         id: "failing",
@@ -608,7 +563,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await thread.execute();
 
@@ -628,49 +583,25 @@ describe("Thread", () => {
     it("should execute tool successfully with result in history", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
-
-          // First call: return tool call
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "add",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: JSON.stringify({ a: 5, b: 3 }),
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // Second call: return terminal message
+        // First call: return tool call
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "add",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: JSON.stringify({ a: 5, b: 3 }),
               },
             ],
             finishReason: "stop",
@@ -681,11 +612,27 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return terminal message
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const addTool = tool({
         id: "add",
@@ -703,11 +650,12 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "Add 5 and 3");
+      const thread = new Thread(kernl, agent, userMessage("Add 5 and 3"));
 
       await thread.execute();
 
-      const history = (thread as any).history as ThreadEvent[];
+      // @ts-expect-error
+      const history = thread.history as ThreadEvent[];
 
       const toolResult = history.find((e) => e.kind === "tool-result");
       expect(toolResult).toEqual({
@@ -725,56 +673,32 @@ describe("Thread", () => {
     it("should execute multiple tools in parallel with exact history", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // First call: return multiple tool calls
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "tool1",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: JSON.stringify({ value: "a" }),
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "tool2",
-                  state: IN_PROGRESS,
-                  callId: "call_2",
-                  arguments: JSON.stringify({ value: "b" }),
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
-
-          // Second call: return terminal message
+        // First call: return multiple tool calls
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "tool1",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: JSON.stringify({ value: "a" }),
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "tool2",
+                state: IN_PROGRESS,
+                callId: "call_2",
+                arguments: JSON.stringify({ value: "b" }),
               },
             ],
             finishReason: "stop",
@@ -785,11 +709,27 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return terminal message
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const tool1 = tool({
         id: "tool1",
@@ -816,7 +756,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await thread.execute();
 
@@ -852,47 +792,24 @@ describe("Thread", () => {
     it("should track tick counter correctly", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
-
-          if (callCount < 3) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: `msg_${callCount}`,
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "simple",
-                  state: IN_PROGRESS,
-                  callId: `call_${callCount}`,
-                  arguments: "{}",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
+        if (callCount < 3) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_final",
+                id: `msg_${callCount}`,
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: `call_${callCount}`,
+                arguments: "{}",
               },
             ],
             finishReason: "stop",
@@ -903,11 +820,26 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_final",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const simpleTool = tool({
         id: "simple",
@@ -927,72 +859,64 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
-      expect(result.state.tick).toBe(3);
+      expect(thread._tick).toBe(3);
     });
 
     it("should accumulate model responses", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
-
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "simple",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: "{}",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 10,
-                outputTokens: 5,
-                totalTokens: 15,
-              },
-              warnings: [],
-            };
-          }
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done" }],
+                content: [],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "{}",
               },
             ],
             finishReason: "stop",
             usage: {
-              inputTokens: 20,
-              outputTokens: 10,
-              totalTokens: 30,
+              inputTokens: 10,
+              outputTokens: 5,
+              totalTokens: 15,
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 20,
+            outputTokens: 10,
+            totalTokens: 30,
+          },
+          warnings: [],
+        };
+      });
 
       const simpleTool = tool({
         id: "simple",
@@ -1012,45 +936,37 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
-      expect(result.state.modelResponses).toHaveLength(2);
-      expect(result.state.modelResponses[0].usage.inputTokens).toBe(10);
-      expect(result.state.modelResponses[1].usage.inputTokens).toBe(20);
+      // Verify the thread executed both turns
+      expect(thread._tick).toBe(2);
+      expect(result.response).toBe("Done");
     });
   });
 
   describe("Terminal State Detection", () => {
     it("should terminate when assistant message has no tool calls", async () => {
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Final response" }],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: "Final response" }],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1060,74 +976,64 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
-      expect(result.state.tick).toBe(1);
+      expect(thread._tick).toBe(1);
     });
 
     it("should continue when assistant message has tool calls", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
-
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [
-                    { kind: "text" as const, text: "Let me use a tool" },
-                  ],
-                },
-                {
-                  kind: "tool-call" as const,
-                  toolId: "simple",
-                  state: IN_PROGRESS,
-                  callId: "call_1",
-                  arguments: "{}",
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Done now" }],
+                content: [{ kind: "text" as const, text: "Let me use a tool" }],
+              },
+              {
+                kind: "tool-call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "{}",
               },
             ],
             finishReason: "stop",
             usage: {
-              inputTokens: 3,
+              inputTokens: 2,
               outputTokens: 2,
-              totalTokens: 5,
+              totalTokens: 4,
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done now" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 3,
+            outputTokens: 2,
+            totalTokens: 5,
+          },
+          warnings: [],
+        };
+      });
 
       const simpleTool = tool({
         id: "simple",
@@ -1147,44 +1053,36 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
       // Should have made 2 calls - first with tool, second without
-      expect(result.state.tick).toBe(2);
+      expect(thread._tick).toBe(2);
     });
   });
 
   describe("Final Output Parsing", () => {
     it("should return text output when responseType is 'text'", async () => {
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Hello, world!" }],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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, world!" }],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1195,12 +1093,12 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
       expect(result.response).toBe("Hello, world!");
-      expect(result.state.tick).toBe(1);
+      expect(thread._tick).toBe(1);
     });
 
     it("should parse and validate structured output with valid JSON", async () => {
@@ -1210,38 +1108,30 @@ describe("Thread", () => {
         email: z.string().email(),
       });
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [
-                  {
-                    kind: "text" as const,
-                    text: '{"name": "Alice", "age": 30, "email": "alice@example.com"}',
-                  },
-                ],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: '{"name": "Alice", "age": 30, "email": "alice@example.com"}',
+                },
+              ],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1252,7 +1142,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
@@ -1268,38 +1158,30 @@ describe("Thread", () => {
         name: z.string(),
       });
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [
-                  {
-                    kind: "text" as const,
-                    text: '{"name": "Alice"', // Invalid JSON - missing closing brace
-                  },
-                ],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: '{"name": "Alice"', // Invalid JSON - missing closing brace
+                },
+              ],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1310,7 +1192,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await expect(thread.execute()).rejects.toThrow(ModelBehaviorError);
     });
@@ -1321,38 +1203,30 @@ describe("Thread", () => {
         age: z.number(),
       });
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [
-                  {
-                    kind: "text" as const,
-                    text: '{"name": "Alice", "age": "thirty"}', // age is string instead of number
-                  },
-                ],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: '{"name": "Alice", "age": "thirty"}', // age is string instead of number
+                },
+              ],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1363,7 +1237,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await expect(thread.execute()).rejects.toThrow(ModelBehaviorError);
     });
@@ -1375,38 +1249,30 @@ describe("Thread", () => {
         email: z.string(),
       });
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [
-                  {
-                    kind: "text" as const,
-                    text: '{"name": "Alice", "age": 30}', // missing email
-                  },
-                ],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: '{"name": "Alice", "age": 30}', // missing email
+                },
+              ],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1417,7 +1283,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       await expect(thread.execute()).rejects.toThrow(ModelBehaviorError);
     });
@@ -1436,44 +1302,36 @@ describe("Thread", () => {
         }),
       });
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          return {
-            content: [
-              {
-                kind: "message" as const,
-                id: "msg_1",
-                role: "assistant" as const,
-                content: [
-                  {
-                    kind: "text" as const,
-                    text: JSON.stringify({
-                      user: {
-                        name: "Bob",
-                        profile: { bio: "Engineer", age: 25 },
-                      },
-                      metadata: { timestamp: "2024-01-01" },
-                    }),
-                  },
-                ],
-              },
-            ],
-            finishReason: "stop",
-            usage: {
-              inputTokens: 2,
-              outputTokens: 2,
-              totalTokens: 4,
+      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: JSON.stringify({
+                    user: {
+                      name: "Bob",
+                      profile: { bio: "Engineer", age: 25 },
+                    },
+                    metadata: { timestamp: "2024-01-01" },
+                  }),
+                },
+              ],
             },
-            warnings: [],
-          };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1484,7 +1342,7 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
@@ -1500,42 +1358,18 @@ describe("Thread", () => {
     it("should continue loop when no text in assistant message", async () => {
       let callCount = 0;
 
-      const model: LanguageModel = {
-        spec: "1.0" as const,
-        provider: "test",
-        modelId: "test-model",
-        async generate(req: LanguageModelRequest) {
-          callCount++;
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
 
-          // First call: return empty message (no text)
-          if (callCount === 1) {
-            return {
-              content: [
-                {
-                  kind: "message" as const,
-                  id: "msg_1",
-                  role: "assistant" as const,
-                  content: [], // No content
-                },
-              ],
-              finishReason: "stop",
-              usage: {
-                inputTokens: 2,
-                outputTokens: 2,
-                totalTokens: 4,
-              },
-              warnings: [],
-            };
-          }
-
-          // Second call: return message with text
+        // First call: return empty message (no text)
+        if (callCount === 1) {
           return {
             content: [
               {
                 kind: "message" as const,
-                id: "msg_2",
+                id: "msg_1",
                 role: "assistant" as const,
-                content: [{ kind: "text" as const, text: "Now I have text" }],
+                content: [], // No content
               },
             ],
             finishReason: "stop",
@@ -1546,11 +1380,27 @@ describe("Thread", () => {
             },
             warnings: [],
           };
-        },
-        stream: async function* () {
-          throw new Error("Not implemented");
-        },
-      };
+        }
+
+        // Second call: return message with text
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Now I have text" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: {
+            inputTokens: 2,
+            outputTokens: 2,
+            totalTokens: 4,
+          },
+          warnings: [],
+        };
+      });
 
       const agent = new Agent({
         id: "test",
@@ -1561,14 +1411,14 @@ describe("Thread", () => {
       });
 
       const kernl = new Kernl();
-      const thread = new Thread(kernl, agent, "test");
+      const thread = new Thread(kernl, agent, userMessage("test"));
 
       const result = await thread.execute();
 
       // Should have made 2 calls
       expect(callCount).toBe(2);
       expect(result.response).toBe("Now I have text");
-      expect(result.state.tick).toBe(2);
+      expect(thread._tick).toBe(2);
     });
   });
 });