kernl 0.1.4 → 0.2.0

package/dist/thread/__tests__/thread.test.js

@@ -6,36 +6,40 @@ import { Agent } from "../../agent";
 import { Kernl } from "../../kernl";
 import { tool, FunctionToolkit } from "../../tool";
 import { ModelBehaviorError } from "../../lib/error";
+import { createMockModel } from "./fixtures/mock-model";
+// Helper to create user message input
+function userMessage(text) {
+    return [
+        {
+            kind: "message",
+            id: "msg-test",
+            role: "user",
+            content: [{ kind: "text", text }],
+        },
+    ];
+}
 describe("Thread", () => {
     describe("Basic Execution", () => {
         it("should execute single turn and terminate with exact history", async () => {
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [{ kind: "text", text: "Hello world" }],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [{ kind: "text", 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",
                 name: "Test",
@@ -43,7 +47,7 @@ describe("Thread", () => {
                 model,
             });
             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();
             // Access private history via type assertion for testing
             const history = thread.history;
@@ -61,37 +65,28 @@ describe("Thread", () => {
                     content: [{ kind: "text", text: "Hello world" }],
                 },
             ]);
-            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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [{ kind: "text", text: "Response" }],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [{ kind: "text", 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",
                 name: "Test",
@@ -99,7 +94,7 @@ describe("Thread", () => {
                 model,
             });
             const kernl = new Kernl();
-            const thread = new Thread(kernl, agent, "Test input");
+            const thread = new Thread(kernl, agent, userMessage("Test input"));
             await thread.execute();
             const history = thread.history;
             const firstMessage = history[0];
@@ -111,33 +106,25 @@ describe("Thread", () => {
             });
         });
         it("should use array input as-is", async () => {
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [{ kind: "text", text: "Response" }],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [{ kind: "text", 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",
                 name: "Test",
@@ -163,62 +150,54 @@ describe("Thread", () => {
     describe("Multi-Turn Execution", () => {
         it("should execute multi-turn with tool call and exact history", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return tool call
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "echo",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: JSON.stringify({ text: "test" }),
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
-                    // Second call: return final message
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return tool call
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done!" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                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",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done!" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 4,
+                        outputTokens: 2,
+                        totalTokens: 6,
+                    },
+                    warnings: [],
+                };
+            });
             const echoTool = tool({
                 id: "echo",
                 description: "Echoes input",
@@ -235,7 +214,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();
             const history = thread.history;
             expect(history).toEqual([
@@ -256,16 +235,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,
@@ -278,91 +257,82 @@ describe("Thread", () => {
                     content: [{ kind: "text", text: "Done!" }],
                 },
             ]);
-            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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "simple",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: "first",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                callCount++;
+                if (callCount === 1) {
+                    return {
+                        content: [
+                            {
+                                kind: "message",
+                                id: "msg_1",
+                                role: "assistant",
+                                content: [],
                             },
-                            warnings: [],
-                        };
-                    }
-                    if (callCount === 2) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_2",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "simple",
-                                    state: IN_PROGRESS,
-                                    callId: "call_2",
-                                    arguments: "second",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 3,
-                                outputTokens: 2,
-                                totalTokens: 5,
+                            {
+                                kind: "tool-call",
+                                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",
-                                id: "msg_3",
+                                id: "msg_2",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "All done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                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",
+                            id: "msg_3",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "All done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 4,
+                        outputTokens: 2,
+                        totalTokens: 6,
+                    },
+                    warnings: [],
+                };
+            });
             const simpleTool = tool({
                 id: "simple",
                 description: "Simple tool",
@@ -379,58 +349,35 @@ 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();
             const history = thread.history;
             // 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);
         });
     });
     describe("Tool Execution", () => {
         it("should handle tool not found with exact error in history", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return tool call
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "nonexistent",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: "{}",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
-                    // Second call: return terminal message
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return tool call
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "nonexistent",
+                                state: IN_PROGRESS,
+                                callId: "call_1",
+                                arguments: "{}",
                             },
                         ],
                         finishReason: "stop",
@@ -441,11 +388,26 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                // Second call: return terminal message
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const agent = new Agent({
                 id: "test",
                 name: "Test",
@@ -454,7 +416,7 @@ describe("Thread", () => {
                 toolkits: [], // No tools available
             });
             const kernl = new Kernl();
-            const thread = new Thread(kernl, agent, "test");
+            const thread = new Thread(kernl, agent, userMessage("test"));
             await thread.execute();
             const history = thread.history;
             // Check that the tool result is an error
@@ -470,47 +432,24 @@ describe("Thread", () => {
         });
         it("should handle tool execution error", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return tool call
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "failing",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: "{}",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
-                    // Second call: return terminal message
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return tool call
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "failing",
+                                state: IN_PROGRESS,
+                                callId: "call_1",
+                                arguments: "{}",
                             },
                         ],
                         finishReason: "stop",
@@ -521,11 +460,26 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                // Second call: return terminal message
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const failingTool = tool({
                 id: "failing",
                 description: "Tool that throws",
@@ -544,7 +498,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();
             const history = thread.history;
             const toolResult = history.find((e) => e.kind === "tool-result");
@@ -559,47 +513,24 @@ describe("Thread", () => {
         });
         it("should execute tool successfully with result in history", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return tool call
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    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: [],
-                        };
-                    }
-                    // Second call: return terminal message
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return tool call
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "add",
+                                state: IN_PROGRESS,
+                                callId: "call_1",
+                                arguments: JSON.stringify({ a: 5, b: 3 }),
                             },
                         ],
                         finishReason: "stop",
@@ -610,11 +541,26 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                // Second call: return terminal message
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const addTool = tool({
                 id: "add",
                 description: "Adds two numbers",
@@ -629,8 +575,9 @@ describe("Thread", () => {
                 toolkits: [new FunctionToolkit({ id: "test-tools", tools: [addTool] })],
             });
             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();
+            // @ts-expect-error
             const history = thread.history;
             const toolResult = history.find((e) => e.kind === "tool-result");
             expect(toolResult).toEqual({
@@ -646,54 +593,31 @@ describe("Thread", () => {
     describe("Parallel Tool Execution", () => {
         it("should execute multiple tools in parallel with exact history", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return multiple tool calls
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "tool1",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: JSON.stringify({ value: "a" }),
-                                },
-                                {
-                                    kind: "tool-call",
-                                    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
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return multiple tool calls
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "tool1",
+                                state: IN_PROGRESS,
+                                callId: "call_1",
+                                arguments: JSON.stringify({ value: "a" }),
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "tool2",
+                                state: IN_PROGRESS,
+                                callId: "call_2",
+                                arguments: JSON.stringify({ value: "b" }),
                             },
                         ],
                         finishReason: "stop",
@@ -704,11 +628,26 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                // Second call: return terminal message
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const tool1 = tool({
                 id: "tool1",
                 description: "Tool 1",
@@ -731,7 +670,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();
             const history = thread.history;
             // Should have both tool results in history
@@ -760,45 +699,23 @@ describe("Thread", () => {
     describe("State Management", () => {
         it("should track tick counter correctly", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    if (callCount < 3) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: `msg_${callCount}`,
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "simple",
-                                    state: IN_PROGRESS,
-                                    callId: `call_${callCount}`,
-                                    arguments: "{}",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
+            const model = createMockModel(async (req) => {
+                callCount++;
+                if (callCount < 3) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_final",
+                                id: `msg_${callCount}`,
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                toolId: "simple",
+                                state: IN_PROGRESS,
+                                callId: `call_${callCount}`,
+                                arguments: "{}",
                             },
                         ],
                         finishReason: "stop",
@@ -809,11 +726,25 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_final",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const simpleTool = tool({
                 id: "simple",
                 description: "Simple tool",
@@ -830,66 +761,58 @@ 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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "simple",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: "{}",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 10,
-                                outputTokens: 5,
-                                totalTokens: 15,
-                            },
-                            warnings: [],
-                        };
-                    }
+            const model = createMockModel(async (req) => {
+                callCount++;
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done" }],
+                                content: [],
+                            },
+                            {
+                                kind: "tool-call",
+                                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",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 20,
+                        outputTokens: 10,
+                        totalTokens: 30,
+                    },
+                    warnings: [],
+                };
+            });
             const simpleTool = tool({
                 id: "simple",
                 description: "Simple tool",
@@ -906,42 +829,34 @@ 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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [{ kind: "text", text: "Final response" }],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [{ kind: "text", 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",
                 name: "Test",
@@ -949,68 +864,58 @@ describe("Thread", () => {
                 model,
             });
             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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [
-                                        { kind: "text", text: "Let me use a tool" },
-                                    ],
-                                },
-                                {
-                                    kind: "tool-call",
-                                    toolId: "simple",
-                                    state: IN_PROGRESS,
-                                    callId: "call_1",
-                                    arguments: "{}",
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
+            const model = createMockModel(async (req) => {
+                callCount++;
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Done now" }],
+                                content: [{ kind: "text", text: "Let me use a tool" }],
+                            },
+                            {
+                                kind: "tool-call",
+                                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",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Done now" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 3,
+                        outputTokens: 2,
+                        totalTokens: 5,
+                    },
+                    warnings: [],
+                };
+            });
             const simpleTool = tool({
                 id: "simple",
                 description: "Simple tool",
@@ -1027,41 +932,33 @@ 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 = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [{ kind: "text", text: "Hello, world!" }],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [{ kind: "text", 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",
                 name: "Test",
@@ -1070,10 +967,10 @@ describe("Thread", () => {
                 responseType: "text",
             });
             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 () => {
             const responseSchema = z.object({
@@ -1081,38 +978,30 @@ describe("Thread", () => {
                 age: z.number(),
                 email: z.string().email(),
             });
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [
-                                    {
-                                        kind: "text",
-                                        text: '{"name": "Alice", "age": 30, "email": "alice@example.com"}',
-                                    },
-                                ],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [
+                                {
+                                    kind: "text",
+                                    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",
                 name: "Test",
@@ -1121,7 +1010,7 @@ describe("Thread", () => {
                 responseType: responseSchema,
             });
             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).toEqual({
                 name: "Alice",
@@ -1133,38 +1022,30 @@ describe("Thread", () => {
             const responseSchema = z.object({
                 name: z.string(),
             });
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [
-                                    {
-                                        kind: "text",
-                                        text: '{"name": "Alice"', // Invalid JSON - missing closing brace
-                                    },
-                                ],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [
+                                {
+                                    kind: "text",
+                                    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",
                 name: "Test",
@@ -1173,7 +1054,7 @@ describe("Thread", () => {
                 responseType: responseSchema,
             });
             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);
         });
         it("should throw ModelBehaviorError when JSON doesn't match schema", async () => {
@@ -1181,38 +1062,30 @@ describe("Thread", () => {
                 name: z.string(),
                 age: z.number(),
             });
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [
-                                    {
-                                        kind: "text",
-                                        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) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [
+                                {
+                                    kind: "text",
+                                    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",
                 name: "Test",
@@ -1221,7 +1094,7 @@ describe("Thread", () => {
                 responseType: responseSchema,
             });
             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);
         });
         it("should throw ModelBehaviorError when required fields are missing", async () => {
@@ -1230,38 +1103,30 @@ describe("Thread", () => {
                 age: z.number(),
                 email: z.string(),
             });
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [
-                                    {
-                                        kind: "text",
-                                        text: '{"name": "Alice", "age": 30}', // missing email
-                                    },
-                                ],
-                            },
-                        ],
-                        finishReason: "stop",
-                        usage: {
-                            inputTokens: 2,
-                            outputTokens: 2,
-                            totalTokens: 4,
+            const model = createMockModel(async (req) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [
+                                {
+                                    kind: "text",
+                                    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",
                 name: "Test",
@@ -1270,7 +1135,7 @@ describe("Thread", () => {
                 responseType: responseSchema,
             });
             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);
         });
         it("should handle nested structured output", async () => {
@@ -1286,44 +1151,36 @@ describe("Thread", () => {
                     timestamp: z.string(),
                 }),
             });
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    return {
-                        content: [
-                            {
-                                kind: "message",
-                                id: "msg_1",
-                                role: "assistant",
-                                content: [
-                                    {
-                                        kind: "text",
-                                        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) => {
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_1",
+                            role: "assistant",
+                            content: [
+                                {
+                                    kind: "text",
+                                    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",
                 name: "Test",
@@ -1332,7 +1189,7 @@ describe("Thread", () => {
                 responseType: responseSchema,
             });
             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).toEqual({
                 user: {
@@ -1344,40 +1201,17 @@ describe("Thread", () => {
         });
         it("should continue loop when no text in assistant message", async () => {
             let callCount = 0;
-            const model = {
-                spec: "1.0",
-                provider: "test",
-                modelId: "test-model",
-                async generate(req) {
-                    callCount++;
-                    // First call: return empty message (no text)
-                    if (callCount === 1) {
-                        return {
-                            content: [
-                                {
-                                    kind: "message",
-                                    id: "msg_1",
-                                    role: "assistant",
-                                    content: [], // No content
-                                },
-                            ],
-                            finishReason: "stop",
-                            usage: {
-                                inputTokens: 2,
-                                outputTokens: 2,
-                                totalTokens: 4,
-                            },
-                            warnings: [],
-                        };
-                    }
-                    // Second call: return message with text
+            const model = createMockModel(async (req) => {
+                callCount++;
+                // First call: return empty message (no text)
+                if (callCount === 1) {
                     return {
                         content: [
                             {
                                 kind: "message",
-                                id: "msg_2",
+                                id: "msg_1",
                                 role: "assistant",
-                                content: [{ kind: "text", text: "Now I have text" }],
+                                content: [], // No content
                             },
                         ],
                         finishReason: "stop",
@@ -1388,11 +1222,26 @@ describe("Thread", () => {
                         },
                         warnings: [],
                     };
-                },
-                stream: async function* () {
-                    throw new Error("Not implemented");
-                },
-            };
+                }
+                // Second call: return message with text
+                return {
+                    content: [
+                        {
+                            kind: "message",
+                            id: "msg_2",
+                            role: "assistant",
+                            content: [{ kind: "text", text: "Now I have text" }],
+                        },
+                    ],
+                    finishReason: "stop",
+                    usage: {
+                        inputTokens: 2,
+                        outputTokens: 2,
+                        totalTokens: 4,
+                    },
+                    warnings: [],
+                };
+            });
             const agent = new Agent({
                 id: "test",
                 name: "Test",
@@ -1401,12 +1250,12 @@ describe("Thread", () => {
                 responseType: "text",
             });
             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);
         });
     });
 });