kernl 0.11.4 → 0.12.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> kernl@0.11.4 build /home/runner/work/kernl/kernl/packages/kernl
+> kernl@0.12.0 build /home/runner/work/kernl/kernl/packages/kernl
 > tsc && tsc-alias --resolve-full-paths
 

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @kernl/core
 
+## 0.12.0
+
+### Minor Changes
+
+- 8815744: **BREAKING:** Refactor event kind naming from kebab-case to dot notation
+
+  This aligns the language model stream/item kinds with the existing realtime events naming convention.
+
+  ### Kind value changes
+
+  | Old                | New                |
+  | ------------------ | ------------------ |
+  | `tool-call`        | `tool.call`        |
+  | `tool-result`      | `tool.result`      |
+  | `text-start`       | `text.start`       |
+  | `text-delta`       | `text.delta`       |
+  | `text-end`         | `text.end`         |
+  | `reasoning-start`  | `reasoning.start`  |
+  | `reasoning-delta`  | `reasoning.delta`  |
+  | `reasoning-end`    | `reasoning.end`    |
+  | `tool-input-start` | `tool.input.start` |
+  | `tool-input-delta` | `tool.input.delta` |
+  | `tool-input-end`   | `tool.input.end`   |
+  | `stream-start`     | `stream.start`     |
+
+  ### ToolInputStartEvent: `toolName` → `toolId`
+
+  The `ToolInputStartEvent` now uses `toolId` to match `ToolCall` and `ToolResult`.
+
+  ### Migration
+
+  If you have persisted thread events, run:
+
+  ```sql
+  UPDATE thread_events SET kind = 'tool.call' WHERE kind = 'tool-call';
+  UPDATE thread_events SET kind = 'tool.result' WHERE kind = 'tool-result';
+  ```
+
+### Patch Changes
+
+- Updated dependencies [8815744]
+  - @kernl-sdk/protocol@0.5.0
+  - @kernl-sdk/retrieval@0.1.9
+
 ## 0.11.4
 
 ### Patch Changes

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

@@ -218,7 +218,7 @@ describe("Agent.stream() lifecycle", () => {
         for await (const event of agent.stream("Hello")) {
             events.push(event);
         }
-        expect(events[0]).toEqual({ kind: "stream-start" });
+        expect(events[0]).toEqual({ kind: "stream.start" });
     });
     it("should have same persistence behavior as run()", async () => {
         const storage = new InMemoryStorage();
@@ -247,7 +247,7 @@ describe("Agent.stream() lifecycle", () => {
         expect(history.length).toBeGreaterThan(0);
         // Should have streamed events
         expect(events).toEqual(expect.arrayContaining([
-            { kind: "stream-start" },
+            { kind: "stream.start" },
             expect.objectContaining({ kind: "message" }),
         ]));
     });

package/dist/lifecycle/__tests__/hooks.test.js

@@ -238,7 +238,7 @@ describe("Lifecycle Hooks", () => {
                         content: [
                             message({ role: "assistant", text: "" }),
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "echo",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -302,7 +302,7 @@ describe("Lifecycle Hooks", () => {
                         content: [
                             message({ role: "assistant", text: "" }),
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "add",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -359,7 +359,7 @@ describe("Lifecycle Hooks", () => {
                         content: [
                             message({ role: "assistant", text: "" }),
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "add",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -415,7 +415,7 @@ describe("Lifecycle Hooks", () => {
                         content: [
                             message({ role: "assistant", text: "" }),
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "failing",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -473,14 +473,14 @@ describe("Lifecycle Hooks", () => {
                         content: [
                             message({ role: "assistant", text: "" }),
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "tool1",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
                                 arguments: JSON.stringify({ value: "a" }),
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "tool2",
                                 state: IN_PROGRESS,
                                 callId: "call_2",

package/dist/storage/__tests__/in-memory.test.js

@@ -312,7 +312,7 @@ describe("InMemoryThreadStore", () => {
         it("should filter by kinds", async () => {
             await store.append([
                 {
-                    kind: "tool-call",
+                    kind: "tool.call",
                     id: "tc-1",
                     tid: "thread-1",
                     seq: 3,

package/dist/thread/__tests__/fixtures/mock-model.js

@@ -10,18 +10,18 @@ async function* streamFromResponse(response) {
                 if (contentItem.kind === "text") {
                     // Yield text-start
                     yield {
-                        kind: "text-start",
+                        kind: "text.start",
                         id: item.id,
                     };
                     // Yield text-delta
                     yield {
-                        kind: "text-delta",
+                        kind: "text.delta",
                         id: item.id,
                         text: contentItem.text,
                     };
                     // Yield text-end
                     yield {
-                        kind: "text-end",
+                        kind: "text.end",
                         id: item.id,
                     };
                 }

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

@@ -48,13 +48,13 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
             }
             expect(events.length).toBeGreaterThan(0);
             // Should have text-delta events (for streaming UX)
-            const textDeltas = events.filter((e) => e.kind === "text-delta");
+            const textDeltas = events.filter((e) => e.kind === "text.delta");
             expect(textDeltas.length).toBeGreaterThan(0);
             // Should have text-start event
-            const textStarts = events.filter((e) => e.kind === "text-start");
+            const textStarts = events.filter((e) => e.kind === "text.start");
             expect(textStarts.length).toBeGreaterThan(0);
             // Should have text-end event
-            const textEnds = events.filter((e) => e.kind === "text-end");
+            const textEnds = events.filter((e) => e.kind === "text.end");
             expect(textEnds.length).toBeGreaterThan(0);
             // Should have complete Message item (for history)
             const messages = events.filter((e) => e.kind === "message");
@@ -103,9 +103,9 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                 expect(["message", "reasoning", "tool-call", "tool-result"]).toContain(event.kind);
             }
             // Stream events should include deltas (but history should not)
-            const streamDeltas = streamEvents.filter((e) => e.kind === "text-delta" ||
-                e.kind === "text-start" ||
-                e.kind === "text-end");
+            const streamDeltas = streamEvents.filter((e) => e.kind === "text.delta" ||
+                e.kind === "text.start" ||
+                e.kind === "text.end");
             expect(streamDeltas.length).toBeGreaterThan(0);
             // History should contain the input message (with ThreadEvent headers added)
             expect(history[0]).toMatchObject({
@@ -162,14 +162,14 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
             }
             expect(events.length).toBeGreaterThan(0);
             // Should have tool calls
-            const toolCalls = events.filter((e) => e.kind === "tool-call");
+            const toolCalls = events.filter((e) => e.kind === "tool.call");
             expect(toolCalls.length).toBeGreaterThan(0);
             // Verify tool was called with correct parameters
             const addToolCall = toolCalls.find((tc) => tc.toolId === "add");
             expect(addToolCall).toBeDefined();
             expect(JSON.parse(addToolCall.arguments)).toEqual({ a: 25, b: 17 });
             // Should have tool results
-            const toolResults = events.filter((e) => e.kind === "tool-result");
+            const toolResults = events.filter((e) => e.kind === "tool.result");
             expect(toolResults.length).toBeGreaterThan(0);
             // Verify tool result is correct
             const addToolResult = toolResults.find((tr) => tr.callId === addToolCall.callId);
@@ -177,8 +177,8 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
             expect(addToolResult.result).toBe(42);
             // History should contain tool calls and results
             const history = thread.history;
-            const historyToolCalls = history.filter((e) => e.kind === "tool-call");
-            const historyToolResults = history.filter((e) => e.kind === "tool-result");
+            const historyToolCalls = history.filter((e) => e.kind === "tool.call");
+            const historyToolResults = history.filter((e) => e.kind === "tool.result");
             expect(historyToolCalls.length).toBe(toolCalls.length);
             expect(historyToolResults.length).toBe(toolResults.length);
             // Verify the assistant's final response references the correct answer
@@ -228,8 +228,8 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                 events.push(event);
             }
             // Find the tool call and result
-            const toolCalls = events.filter((e) => e.kind === "tool-call");
-            const toolResults = events.filter((e) => e.kind === "tool-result");
+            const toolCalls = events.filter((e) => e.kind === "tool.call");
+            const toolResults = events.filter((e) => e.kind === "tool.result");
             expect(toolCalls.length).toBeGreaterThan(0);
             expect(toolResults.length).toBeGreaterThan(0);
             const multiplyCall = toolCalls[0];
@@ -244,8 +244,8 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
             expect(multiplyResult.callId.length).toBeGreaterThan(0);
             // Verify history contains both with matching callIds
             const history = thread.history;
-            const historyToolCall = history.find((e) => e.kind === "tool-call" && e.toolId === "multiply");
-            const historyToolResult = history.find((e) => e.kind === "tool-result" && e.toolId === "multiply");
+            const historyToolCall = history.find((e) => e.kind === "tool.call" && e.toolId === "multiply");
+            const historyToolResult = history.find((e) => e.kind === "tool.result" && e.toolId === "multiply");
             expect(historyToolCall).toBeDefined();
             expect(historyToolResult).toBeDefined();
             expect(historyToolCall.callId).toBe(historyToolResult.callId);

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

@@ -67,7 +67,7 @@ describe("Thread Persistence", () => {
             //     return {
             //       content: [
             //         message({ role: "assistant", text: "" }),
-            //         { kind: "tool-call", toolId: "test", callId: "call_1", state: IN_PROGRESS, arguments: "{}" },
+            //         { kind: "tool.call", toolId: "test", callId: "call_1", state: IN_PROGRESS, arguments: "{}" },
             //       ],
             //       finishReason: "stop",
             //       usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
@@ -127,7 +127,7 @@ describe("Thread Persistence", () => {
             //     return {
             //       content: [
             //         message({ role: "assistant", text: "" }),
-            //         { kind: "tool-call", toolId: "echo", callId: "call_1", state: IN_PROGRESS, arguments: '{"text":"test"}' },
+            //         { kind: "tool.call", toolId: "echo", callId: "call_1", state: IN_PROGRESS, arguments: '{"text":"test"}' },
             //       ],
             //       finishReason: "stop",
             //       usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
@@ -167,7 +167,7 @@ describe("Thread Persistence", () => {
             //
             // // Find the append call for tick 1 (should include model message, tool-call, and tool-result)
             // const tick1Events = storage.calls.append.find(batch =>
-            //   batch.some(e => e.kind === "tool-result")
+            //   batch.some(e => e.kind === "tool.result")
             // );
             //
             // expect(tick1Events).toBeDefined();
@@ -177,8 +177,8 @@ describe("Thread Persistence", () => {
             // expect(tick1Events).toEqual(
             //   expect.arrayContaining([
             //     expect.objectContaining({ kind: "message", role: "assistant" }),
-            //     expect.objectContaining({ kind: "tool-call", toolId: "echo" }),
-            //     expect.objectContaining({ kind: "tool-result", toolId: "echo", result: "Echo: test" }),
+            //     expect.objectContaining({ kind: "tool.call", toolId: "echo" }),
+            //     expect.objectContaining({ kind: "tool.result", toolId: "echo", result: "Echo: test" }),
             //   ])
             // );
         });
@@ -220,7 +220,7 @@ describe("Thread Persistence", () => {
             // expect(lastUpdate.patch.state).toBe(STOPPED);
             //
             // // Verify stream-start event
-            // expect(events[0]).toEqual({ kind: "stream-start" });
+            // expect(events[0]).toEqual({ kind: "stream.start" });
         });
         it.skip("should persist STOPPED state even on model error", async () => {
             // TODO: Enable once InMemoryStorage is implemented

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

@@ -164,7 +164,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "echo",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -233,7 +233,7 @@ describe("Thread", () => {
                 }),
                 // Tool call (tick 1)
                 expect.objectContaining({
-                    kind: "tool-call",
+                    kind: "tool.call",
                     toolId: "echo",
                     callId: "call_1",
                     state: IN_PROGRESS,
@@ -241,7 +241,7 @@ describe("Thread", () => {
                 }),
                 // Tool result (executed after tick 1)
                 expect.objectContaining({
-                    kind: "tool-result",
+                    kind: "tool.result",
                     callId: "call_1",
                     toolId: "echo",
                     state: COMPLETED,
@@ -271,7 +271,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "simple",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -297,7 +297,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "simple",
                                 state: IN_PROGRESS,
                                 callId: "call_2",
@@ -371,7 +371,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "nonexistent",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -418,9 +418,9 @@ describe("Thread", () => {
             await thread.execute();
             const history = thread.history;
             // Check that the tool result is an error
-            const toolResult = history.find((e) => e.kind === "tool-result");
+            const toolResult = history.find((e) => e.kind === "tool.result");
             expect(toolResult).toEqual(expect.objectContaining({
-                kind: "tool-result",
+                kind: "tool.result",
                 callId: "call_1",
                 toolId: "nonexistent",
                 state: FAILED,
@@ -443,7 +443,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "failing",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -499,9 +499,9 @@ describe("Thread", () => {
             const thread = new Thread({ agent, input: userMessage("test") });
             await thread.execute();
             const history = thread.history;
-            const toolResult = history.find((e) => e.kind === "tool-result");
+            const toolResult = history.find((e) => e.kind === "tool.result");
             expect(toolResult).toMatchObject({
-                kind: "tool-result",
+                kind: "tool.result",
                 callId: "call_1",
                 toolId: "failing",
                 state: FAILED,
@@ -524,7 +524,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "add",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -577,9 +577,9 @@ describe("Thread", () => {
             await thread.execute();
             // @ts-expect-error
             const history = thread.history;
-            const toolResult = history.find((e) => e.kind === "tool-result");
+            const toolResult = history.find((e) => e.kind === "tool.result");
             expect(toolResult).toEqual(expect.objectContaining({
-                kind: "tool-result",
+                kind: "tool.result",
                 callId: "call_1",
                 toolId: "add",
                 state: COMPLETED,
@@ -604,14 +604,14 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "tool1",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
                                 arguments: JSON.stringify({ value: "a" }),
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "tool2",
                                 state: IN_PROGRESS,
                                 callId: "call_2",
@@ -672,11 +672,11 @@ describe("Thread", () => {
             await thread.execute();
             const history = thread.history;
             // Should have both tool results in history
-            const toolResults = history.filter((e) => e.kind === "tool-result");
+            const toolResults = history.filter((e) => e.kind === "tool.result");
             expect(toolResults).toHaveLength(2);
             expect(toolResults).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    kind: "tool-result",
+                    kind: "tool.result",
                     callId: "call_1",
                     toolId: "tool1",
                     state: COMPLETED,
@@ -684,7 +684,7 @@ describe("Thread", () => {
                     error: null,
                 }),
                 expect.objectContaining({
-                    kind: "tool-result",
+                    kind: "tool.result",
                     callId: "call_2",
                     toolId: "tool2",
                     state: COMPLETED,
@@ -709,7 +709,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "simple",
                                 state: IN_PROGRESS,
                                 callId: `call_${callCount}`,
@@ -777,7 +777,7 @@ describe("Thread", () => {
                                 content: [],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "simple",
                                 state: IN_PROGRESS,
                                 callId: "call_1",
@@ -880,7 +880,7 @@ describe("Thread", () => {
                                 content: [{ kind: "text", text: "Let me use a tool" }],
                             },
                             {
-                                kind: "tool-call",
+                                kind: "tool.call",
                                 toolId: "simple",
                                 state: IN_PROGRESS,
                                 callId: "call_1",

package/dist/thread/thread.js

@@ -127,7 +127,7 @@ export class Thread {
             namespace: this.namespace,
             context: this.context,
         });
-        yield { kind: "stream-start" }; // always yield start immediately
+        yield { kind: "stream.start" }; // always yield start immediately
         try {
             yield* this._execute();
             this.agent.emit("thread.stop", {
@@ -380,7 +380,7 @@ export class Thread {
         const pendingApprovals = [];
         // (TODO): clean this - approval tracking should be handled differently
         for (const e of toolEvents) {
-            if (e.kind === "tool-result" &&
+            if (e.kind === "tool.result" &&
                 e.state === "requires_approval" // (TODO): fix this
             ) {
                 // find the original tool call for this pending approval
@@ -440,7 +440,7 @@ export class Thread {
                     error: res.error,
                 });
                 return {
-                    kind: "tool-result",
+                    kind: "tool.result",
                     callId: call.callId,
                     toolId: call.toolId,
                     state: res.state,
@@ -460,7 +460,7 @@ export class Thread {
                     error: error instanceof Error ? error.message : String(error),
                 });
                 return {
-                    kind: "tool-result",
+                    kind: "tool.result",
                     callId: call.callId,
                     toolId: call.toolId,
                     state: FAILED,

package/dist/thread/utils.js

@@ -32,7 +32,7 @@ export function tevent(event) {
  * Check if an event is a tool call
  */
 export function isActionIntention(event) {
-    return event.kind === "tool-call";
+    return event.kind === "tool.call";
 }
 /**
  * Extract action intentions from a list of events.
@@ -50,8 +50,8 @@ export function notDelta(event) {
     switch (event.kind) {
         case "message":
         case "reasoning":
-        case "tool-call":
-        case "tool-result":
+        case "tool.call":
+        case "tool.result":
             return true;
         // all other events are streaming deltas/control events
         default:
@@ -66,8 +66,8 @@ export function isPublicEvent(event) {
     switch (event.kind) {
         case "message":
         case "reasoning":
-        case "tool-call":
-        case "tool-result":
+        case "tool.call":
+        case "tool.result":
             return true;
         case "system":
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernl",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "description": "A modern AI agent framework",
   "keywords": [
     "kernl",
@@ -34,9 +34,9 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.2",
     "yaml": "^2.8.2",
-    "@kernl-sdk/protocol": "0.4.2",
-    "@kernl-sdk/shared": "^0.4.0",
-    "@kernl-sdk/retrieval": "0.1.8"
+    "@kernl-sdk/protocol": "0.5.0",
+    "@kernl-sdk/retrieval": "0.1.9",
+    "@kernl-sdk/shared": "^0.4.0"
   },
   "peerDependencies": {
     "zod": "^4.1.8"
@@ -48,7 +48,7 @@
     "typescript": "5.9.2",
     "vitest": "^4.0.8",
     "zod": "^4.1.8",
-    "@kernl-sdk/ai": "0.3.5"
+    "@kernl-sdk/ai": "0.4.0"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/agent/__tests__/run.test.ts

@@ -268,7 +268,7 @@ describe("Agent.stream() lifecycle", () => {
       events.push(event);
     }
 
-    expect(events[0]).toEqual({ kind: "stream-start" });
+    expect(events[0]).toEqual({ kind: "stream.start" });
   });
 
   it("should have same persistence behavior as run()", async () => {
@@ -305,7 +305,7 @@ describe("Agent.stream() lifecycle", () => {
     // Should have streamed events
     expect(events).toEqual(
       expect.arrayContaining([
-        { kind: "stream-start" },
+        { kind: "stream.start" },
         expect.objectContaining({ kind: "message" }),
       ]),
     );

package/src/lifecycle/__tests__/hooks.test.ts

@@ -308,7 +308,7 @@ describe("Lifecycle Hooks", () => {
             content: [
               message({ role: "assistant", text: "" }),
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "echo",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -381,7 +381,7 @@ describe("Lifecycle Hooks", () => {
             content: [
               message({ role: "assistant", text: "" }),
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "add",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -446,7 +446,7 @@ describe("Lifecycle Hooks", () => {
             content: [
               message({ role: "assistant", text: "" }),
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "add",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -510,7 +510,7 @@ describe("Lifecycle Hooks", () => {
             content: [
               message({ role: "assistant", text: "" }),
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "failing",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -576,14 +576,14 @@ describe("Lifecycle Hooks", () => {
             content: [
               message({ role: "assistant", text: "" }),
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "tool1",
                 state: IN_PROGRESS,
                 callId: "call_1",
                 arguments: JSON.stringify({ value: "a" }),
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "tool2",
                 state: IN_PROGRESS,
                 callId: "call_2",

package/src/storage/__tests__/in-memory.test.ts

@@ -367,7 +367,7 @@ describe("InMemoryThreadStore", () => {
     it("should filter by kinds", async () => {
       await store.append([
         {
-          kind: "tool-call",
+          kind: "tool.call",
           id: "tc-1",
           tid: "thread-1",
           seq: 3,

package/src/thread/__tests__/fixtures/mock-model.ts

@@ -20,18 +20,18 @@ async function* streamFromResponse(
         if (contentItem.kind === "text") {
           // Yield text-start
           yield {
-            kind: "text-start" as const,
+            kind: "text.start" as const,
             id: item.id,
           };
           // Yield text-delta
           yield {
-            kind: "text-delta" as const,
+            kind: "text.delta" as const,
             id: item.id,
             text: contentItem.text,
           };
           // Yield text-end
           yield {
-            kind: "text-end" as const,
+            kind: "text.end" as const,
             id: item.id,
           };
         }

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

@@ -63,15 +63,15 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
       expect(events.length).toBeGreaterThan(0);
 
       // Should have text-delta events (for streaming UX)
-      const textDeltas = events.filter((e) => e.kind === "text-delta");
+      const textDeltas = events.filter((e) => e.kind === "text.delta");
       expect(textDeltas.length).toBeGreaterThan(0);
 
       // Should have text-start event
-      const textStarts = events.filter((e) => e.kind === "text-start");
+      const textStarts = events.filter((e) => e.kind === "text.start");
       expect(textStarts.length).toBeGreaterThan(0);
 
       // Should have text-end event
-      const textEnds = events.filter((e) => e.kind === "text-end");
+      const textEnds = events.filter((e) => e.kind === "text.end");
       expect(textEnds.length).toBeGreaterThan(0);
 
       // Should have complete Message item (for history)
@@ -140,9 +140,9 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
       // Stream events should include deltas (but history should not)
       const streamDeltas = streamEvents.filter(
         (e: any) =>
-          e.kind === "text-delta" ||
-          e.kind === "text-start" ||
-          e.kind === "text-end",
+          e.kind === "text.delta" ||
+          e.kind === "text.start" ||
+          e.kind === "text.end",
       );
       expect(streamDeltas.length).toBeGreaterThan(0);
 
@@ -216,8 +216,8 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
 
       // Should have tool calls
       const toolCalls = events.filter(
-        (e): e is Extract<ThreadStreamEvent, { kind: "tool-call" }> =>
-          e.kind === "tool-call",
+        (e): e is Extract<ThreadStreamEvent, { kind: "tool.call" }> =>
+          e.kind === "tool.call",
       );
       expect(toolCalls.length).toBeGreaterThan(0);
 
@@ -228,8 +228,8 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
 
       // Should have tool results
       const toolResults = events.filter(
-        (e): e is Extract<ThreadStreamEvent, { kind: "tool-result" }> =>
-          e.kind === "tool-result",
+        (e): e is Extract<ThreadStreamEvent, { kind: "tool.result" }> =>
+          e.kind === "tool.result",
       );
       expect(toolResults.length).toBeGreaterThan(0);
 
@@ -242,9 +242,9 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
 
       // History should contain tool calls and results
       const history = (thread as any).history as ThreadEvent[];
-      const historyToolCalls = history.filter((e) => e.kind === "tool-call");
+      const historyToolCalls = history.filter((e) => e.kind === "tool.call");
       const historyToolResults = history.filter(
-        (e) => e.kind === "tool-result",
+        (e) => e.kind === "tool.result",
       );
 
       expect(historyToolCalls.length).toBe(toolCalls.length);
@@ -309,12 +309,12 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
 
       // Find the tool call and result
       const toolCalls = events.filter(
-        (e): e is Extract<ThreadStreamEvent, { kind: "tool-call" }> =>
-          e.kind === "tool-call",
+        (e): e is Extract<ThreadStreamEvent, { kind: "tool.call" }> =>
+          e.kind === "tool.call",
       );
       const toolResults = events.filter(
-        (e): e is Extract<ThreadStreamEvent, { kind: "tool-result" }> =>
-          e.kind === "tool-result",
+        (e): e is Extract<ThreadStreamEvent, { kind: "tool.result" }> =>
+          e.kind === "tool.result",
       );
 
       expect(toolCalls.length).toBeGreaterThan(0);
@@ -336,10 +336,10 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
       // Verify history contains both with matching callIds
       const history = (thread as any).history as ThreadEvent[];
       const historyToolCall = history.find(
-        (e) => e.kind === "tool-call" && e.toolId === "multiply",
+        (e) => e.kind === "tool.call" && e.toolId === "multiply",
       );
       const historyToolResult = history.find(
-        (e) => e.kind === "tool-result" && e.toolId === "multiply",
+        (e) => e.kind === "tool.result" && e.toolId === "multiply",
       );
 
       expect(historyToolCall).toBeDefined();

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

@@ -77,7 +77,7 @@ describe("Thread Persistence", () => {
       //     return {
       //       content: [
       //         message({ role: "assistant", text: "" }),
-      //         { kind: "tool-call", toolId: "test", callId: "call_1", state: IN_PROGRESS, arguments: "{}" },
+      //         { kind: "tool.call", toolId: "test", callId: "call_1", state: IN_PROGRESS, arguments: "{}" },
       //       ],
       //       finishReason: "stop",
       //       usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
@@ -138,7 +138,7 @@ describe("Thread Persistence", () => {
       //     return {
       //       content: [
       //         message({ role: "assistant", text: "" }),
-      //         { kind: "tool-call", toolId: "echo", callId: "call_1", state: IN_PROGRESS, arguments: '{"text":"test"}' },
+      //         { kind: "tool.call", toolId: "echo", callId: "call_1", state: IN_PROGRESS, arguments: '{"text":"test"}' },
       //       ],
       //       finishReason: "stop",
       //       usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
@@ -178,7 +178,7 @@ describe("Thread Persistence", () => {
       //
       // // Find the append call for tick 1 (should include model message, tool-call, and tool-result)
       // const tick1Events = storage.calls.append.find(batch =>
-      //   batch.some(e => e.kind === "tool-result")
+      //   batch.some(e => e.kind === "tool.result")
       // );
       //
       // expect(tick1Events).toBeDefined();
@@ -188,8 +188,8 @@ describe("Thread Persistence", () => {
       // expect(tick1Events).toEqual(
       //   expect.arrayContaining([
       //     expect.objectContaining({ kind: "message", role: "assistant" }),
-      //     expect.objectContaining({ kind: "tool-call", toolId: "echo" }),
-      //     expect.objectContaining({ kind: "tool-result", toolId: "echo", result: "Echo: test" }),
+      //     expect.objectContaining({ kind: "tool.call", toolId: "echo" }),
+      //     expect.objectContaining({ kind: "tool.result", toolId: "echo", result: "Echo: test" }),
       //   ])
       // );
     });
@@ -232,7 +232,7 @@ describe("Thread Persistence", () => {
       // expect(lastUpdate.patch.state).toBe(STOPPED);
       //
       // // Verify stream-start event
-      // expect(events[0]).toEqual({ kind: "stream-start" });
+      // expect(events[0]).toEqual({ kind: "stream.start" });
     });
 
     it.skip("should persist STOPPED state even on model error", async () => {

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

@@ -194,7 +194,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "echo",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -270,7 +270,7 @@ describe("Thread", () => {
         }),
         // Tool call (tick 1)
         expect.objectContaining({
-          kind: "tool-call",
+          kind: "tool.call",
           toolId: "echo",
           callId: "call_1",
           state: IN_PROGRESS,
@@ -278,7 +278,7 @@ describe("Thread", () => {
         }),
         // Tool result (executed after tick 1)
         expect.objectContaining({
-          kind: "tool-result",
+          kind: "tool.result",
           callId: "call_1",
           toolId: "echo",
           state: COMPLETED,
@@ -312,7 +312,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "simple",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -339,7 +339,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "simple",
                 state: IN_PROGRESS,
                 callId: "call_2",
@@ -423,7 +423,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "nonexistent",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -476,9 +476,9 @@ describe("Thread", () => {
       const history = (thread as any).history as ThreadEvent[];
 
       // Check that the tool result is an error
-      const toolResult = history.find((e) => e.kind === "tool-result");
+      const toolResult = history.find((e) => e.kind === "tool.result");
       expect(toolResult).toEqual(expect.objectContaining({
-        kind: "tool-result",
+        kind: "tool.result",
         callId: "call_1",
         toolId: "nonexistent",
         state: FAILED,
@@ -504,7 +504,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "failing",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -567,9 +567,9 @@ describe("Thread", () => {
 
       const history = (thread as any).history as ThreadEvent[];
 
-      const toolResult = history.find((e) => e.kind === "tool-result");
+      const toolResult = history.find((e) => e.kind === "tool.result");
       expect(toolResult).toMatchObject({
-        kind: "tool-result",
+        kind: "tool.result",
         callId: "call_1",
         toolId: "failing",
         state: FAILED,
@@ -595,7 +595,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "add",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -655,9 +655,9 @@ describe("Thread", () => {
       // @ts-expect-error
       const history = thread.history as ThreadEvent[];
 
-      const toolResult = history.find((e) => e.kind === "tool-result");
+      const toolResult = history.find((e) => e.kind === "tool.result");
       expect(toolResult).toEqual(expect.objectContaining({
-        kind: "tool-result",
+        kind: "tool.result",
         callId: "call_1",
         toolId: "add",
         state: COMPLETED,
@@ -685,14 +685,14 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "tool1",
                 state: IN_PROGRESS,
                 callId: "call_1",
                 arguments: JSON.stringify({ value: "a" }),
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "tool2",
                 state: IN_PROGRESS,
                 callId: "call_2",
@@ -761,12 +761,12 @@ describe("Thread", () => {
       const history = (thread as any).history as ThreadEvent[];
 
       // Should have both tool results in history
-      const toolResults = history.filter((e) => e.kind === "tool-result");
+      const toolResults = history.filter((e) => e.kind === "tool.result");
       expect(toolResults).toHaveLength(2);
       expect(toolResults).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
-            kind: "tool-result",
+            kind: "tool.result",
             callId: "call_1",
             toolId: "tool1",
             state: COMPLETED,
@@ -774,7 +774,7 @@ describe("Thread", () => {
             error: null,
           }),
           expect.objectContaining({
-            kind: "tool-result",
+            kind: "tool.result",
             callId: "call_2",
             toolId: "tool2",
             state: COMPLETED,
@@ -803,7 +803,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "simple",
                 state: IN_PROGRESS,
                 callId: `call_${callCount}`,
@@ -880,7 +880,7 @@ describe("Thread", () => {
                 content: [],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "simple",
                 state: IN_PROGRESS,
                 callId: "call_1",
@@ -997,7 +997,7 @@ describe("Thread", () => {
                 content: [{ kind: "text" as const, text: "Let me use a tool" }],
               },
               {
-                kind: "tool-call" as const,
+                kind: "tool.call" as const,
                 toolId: "simple",
                 state: IN_PROGRESS,
                 callId: "call_1",

package/src/thread/thread.ts

@@ -184,7 +184,7 @@ export class Thread<
       context: this.context,
     });
 
-    yield { kind: "stream-start" }; // always yield start immediately
+    yield { kind: "stream.start" }; // always yield start immediately
 
     try {
       yield* this._execute();
@@ -470,7 +470,7 @@ export class Thread<
     // (TODO): clean this - approval tracking should be handled differently
     for (const e of toolEvents) {
       if (
-        e.kind === "tool-result" &&
+        e.kind === "tool.result" &&
         (e.state as any) === "requires_approval" // (TODO): fix this
       ) {
         // find the original tool call for this pending approval
@@ -542,7 +542,7 @@ export class Thread<
           });
 
           return {
-            kind: "tool-result" as const,
+            kind: "tool.result" as const,
             callId: call.callId,
             toolId: call.toolId,
             state: res.state,
@@ -562,7 +562,7 @@ export class Thread<
           });
 
           return {
-            kind: "tool-result" as const,
+            kind: "tool.result" as const,
             callId: call.callId,
             toolId: call.toolId,
             state: FAILED,

package/src/thread/utils.ts

@@ -58,7 +58,7 @@ export function tevent(event: {
  * Check if an event is a tool call
  */
 export function isActionIntention(event: LanguageModelItem): event is ToolCall {
-  return event.kind === "tool-call";
+  return event.kind === "tool.call";
 }
 
 /**
@@ -78,8 +78,8 @@ export function notDelta(event: ThreadStreamEvent): event is LanguageModelItem {
   switch (event.kind) {
     case "message":
     case "reasoning":
-    case "tool-call":
-    case "tool-result":
+    case "tool.call":
+    case "tool.result":
       return true;
 
     // all other events are streaming deltas/control events
@@ -96,8 +96,8 @@ export function isPublicEvent(event: ThreadEvent): event is PublicThreadEvent {
   switch (event.kind) {
     case "message":
     case "reasoning":
-    case "tool-call":
-    case "tool-result":
+    case "tool.call":
+    case "tool.result":
       return true;
 
     case "system":