kernl 0.12.3 → 0.12.6

package/dist/tracing/subscribers/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../src/tracing/subscribers/console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,UAAU;IAClD,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIjC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM;IAYnD,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ3B,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO1B,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQtD,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAOzC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAS3B,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAI7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD,OAAO,CAAC,GAAG;CAeZ"}

package/dist/tracing/subscribers/console.js

@@ -0,0 +1,82 @@
+/**
+ * A simple console subscriber for development and debugging.
+ * Logs span lifecycle events and events to the console.
+ */
+export class ConsoleSubscriber {
+    spans = new Map();
+    nextId = 0;
+    enabled(_data) {
+        return true;
+    }
+    span(data, parent) {
+        const id = `span_${this.nextId++}`;
+        this.spans.set(id, {
+            data,
+            parent,
+            startTime: Date.now(),
+            entered: false,
+        });
+        console.log(`[span:new] ${id} ${data.kind}`, this.fmt(data));
+        return id;
+    }
+    enter(spanId) {
+        const record = this.spans.get(spanId);
+        if (record) {
+            record.entered = true;
+            console.log(`[span:enter] ${spanId} ${record.data.kind}`);
+        }
+    }
+    exit(spanId) {
+        const record = this.spans.get(spanId);
+        if (record) {
+            console.log(`[span:exit] ${spanId} ${record.data.kind}`);
+        }
+    }
+    record(spanId, delta) {
+        const record = this.spans.get(spanId);
+        if (record) {
+            Object.assign(record.data, delta);
+            console.log(`[span:record] ${spanId}`, this.fmt(delta));
+        }
+    }
+    error(spanId, error) {
+        const record = this.spans.get(spanId);
+        if (record) {
+            console.log(`[span:error] ${spanId} ${record.data.kind}`, error.message);
+        }
+    }
+    close(spanId) {
+        const record = this.spans.get(spanId);
+        if (record) {
+            const duration = Date.now() - record.startTime;
+            console.log(`[span:close] ${spanId} ${record.data.kind} (${duration}ms)`);
+            this.spans.delete(spanId);
+        }
+    }
+    event(data, parent) {
+        console.log(`[event] ${data.kind}`, { ...data, parent });
+    }
+    async flush() {
+        // Console subscriber doesn't buffer
+    }
+    async shutdown(_timeout) {
+        this.spans.clear();
+    }
+    fmt(data) {
+        const { kind, ...rest } = data;
+        // Truncate large fields for readability
+        const formatted = {};
+        for (const [key, value] of Object.entries(rest)) {
+            if (typeof value === "string" && value.length > 100) {
+                formatted[key] = value.slice(0, 100) + "...";
+            }
+            else if (Array.isArray(value) && value.length > 3) {
+                formatted[key] = `[${value.length} items]`;
+            }
+            else {
+                formatted[key] = value;
+            }
+        }
+        return formatted;
+    }
+}

package/dist/tracing/types.d.ts

@@ -0,0 +1,77 @@
+import type { LanguageModelItem, LanguageModelTool, LanguageModelUsage, LanguageModelFinishReason, LanguageModelResponseItem, LanguageModelRequestSettings, LanguageModelResponseType, SharedWarning, ToolCallState } from "@kernl-sdk/protocol";
+import { ThreadState } from "../internal.js";
+export type SpanId = string;
+export interface ThreadSpan {
+    kind: "thread";
+    threadId: string;
+    agentId: string;
+    namespace: string;
+    context?: unknown;
+    state?: ThreadState;
+    result?: unknown;
+    error?: string;
+}
+export interface ModelCallSpan {
+    kind: "model.call";
+    provider: string;
+    modelId: string;
+    request?: {
+        input: LanguageModelItem[];
+        settings?: LanguageModelRequestSettings;
+        responseType?: LanguageModelResponseType;
+        tools?: LanguageModelTool[];
+    };
+    response?: {
+        content: LanguageModelResponseItem[];
+        finishReason: LanguageModelFinishReason;
+        usage?: LanguageModelUsage;
+        warnings?: SharedWarning[];
+    };
+}
+export interface ToolCallSpan {
+    kind: "tool.call";
+    toolId: string;
+    callId: string;
+    args?: Record<string, unknown>;
+    state?: ToolCallState;
+    result?: string;
+    error?: string | null;
+}
+export type SpanData = ThreadSpan | ModelCallSpan | ToolCallSpan;
+export type SpanKind = SpanData["kind"];
+export interface ThreadErrorEvent {
+    kind: "thread.error";
+    message: string;
+    stack?: string;
+}
+export interface ThreadAbortedEvent {
+    kind: "thread.aborted";
+    reason?: string;
+}
+export interface ThreadGuardrailTriggeredEvent {
+    kind: "thread.guardrail_triggered";
+    name: string;
+    type: "input" | "output";
+    passed: boolean;
+    reason?: string;
+}
+export interface ToolApprovalRequestedEvent {
+    kind: "tool.approval_requested";
+    toolId: string;
+    callId: string;
+}
+export interface ToolApprovalGrantedEvent {
+    kind: "tool.approval_granted";
+    toolId: string;
+    callId: string;
+    approver?: string;
+}
+export interface ToolApprovalDeniedEvent {
+    kind: "tool.approval_denied";
+    toolId: string;
+    callId: string;
+    reason?: string;
+}
+export type EventData = ThreadErrorEvent | ThreadAbortedEvent | ThreadGuardrailTriggeredEvent | ToolApprovalRequestedEvent | ToolApprovalGrantedEvent | ToolApprovalDeniedEvent;
+export type EventKind = EventData["kind"];
+//# sourceMappingURL=types.d.ts.map

package/dist/tracing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tracing/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,aAAa,EACb,aAAa,EACd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAMzC,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAC3B,QAAQ,CAAC,EAAE,4BAA4B,CAAC;QACxC,YAAY,CAAC,EAAE,yBAAyB,CAAC;QACzC,KAAK,CAAC,EAAE,iBAAiB,EAAE,CAAC;KAC7B,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,OAAO,EAAE,yBAAyB,EAAE,CAAC;QACrC,YAAY,EAAE,yBAAyB,CAAC;QACxC,KAAK,CAAC,EAAE,kBAAkB,CAAC;QAC3B,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;KAC5B,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,CAAC;AACjE,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;AAMxC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,4BAA4B,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,yBAAyB,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,uBAAuB,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,kBAAkB,GAClB,6BAA6B,GAC7B,0BAA0B,GAC1B,wBAAwB,GACxB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC"}

package/dist/tracing/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernl",
-  "version": "0.12.3",
+  "version": "0.12.6",
   "description": "A modern AI agent framework",
   "keywords": [
     "kernl",
@@ -29,10 +29,14 @@
     "./internal": {
       "types": "./dist/internal.d.ts",
       "import": "./dist/internal.js"
+    },
+    "./tracing": {
+      "types": "./dist/tracing/index.d.ts",
+      "import": "./dist/tracing/index.js"
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.20.2",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "yaml": "^2.8.2",
     "@kernl-sdk/protocol": "0.5.1",
     "@kernl-sdk/retrieval": "0.1.10",

package/src/agent.ts

@@ -115,6 +115,7 @@ export class Agent<
         tid: options?.threadId,
         namespace: options?.namespace,
         storage: this.kernl.storage?.threads,
+        abort: options?.abort,
       });
       return this.kernl.spawn(thread);
     }
@@ -186,6 +187,7 @@ export class Agent<
         tid: options?.threadId,
         namespace: options?.namespace,
         storage: this.kernl.storage?.threads,
+        abort: options?.abort,
       });
       yield* this.kernl.spawnStream(thread);
       return;

package/src/index.ts

@@ -102,3 +102,4 @@ export type {
   MemoryByte,
   MemoryByteCodec,
 } from "./memory";
+

package/src/kernl/kernl.ts

@@ -12,6 +12,7 @@ import {
   MemoryIndexHandle,
   buildMemoryIndexSchema,
 } from "@/memory";
+import { setSubscriber, clearSubscriber, type Subscriber } from "@/tracing";
 
 import { logger } from "@/lib/logger";
 import { RThreads } from "@/api/resources/threads";
@@ -33,6 +34,7 @@ export class Kernl extends KernlHooks {
   private readonly _models: ModelRegistry;
   private readonly _memopts: MemoryOptions | undefined;
   private readonly _storopts: StorageOptions | undefined;
+  private readonly _subscriber: Subscriber | null = null;
 
   readonly storage: KernlStorage;
   athreads: Map<string, Thread<any, any>> = new Map(); /* active threads */
@@ -60,6 +62,12 @@ export class Kernl extends KernlHooks {
     this.threads = new RThreads(this.storage.threads);
     this.agents = new RAgents(this._agents);
     this.memories = this.initmem();
+
+    // wire tracing
+    if (options.tracer) {
+      this._subscriber = options.tracer;
+      setSubscriber(this._subscriber);
+    }
   }
 
   /**
@@ -196,4 +204,17 @@ export class Kernl extends KernlHooks {
       encoder,
     });
   }
+
+  /**
+   * Gracefully shutdown the Kernl instance.
+   * Flushes and shuts down tracing subscribers, closes storage connections.
+   */
+  async shutdown(timeout?: number): Promise<void> {
+    if (this._subscriber) {
+      await this._subscriber.flush();
+      await this._subscriber.shutdown(timeout);
+      clearSubscriber();
+    }
+    // TODO: close storage connections when storage supports it
+  }
 }

package/src/kernl/types.ts

@@ -3,6 +3,7 @@ import { SearchIndex } from "@kernl-sdk/retrieval";
 
 import { BaseAgent } from "@/agent/base";
 import { KernlStorage } from "@/storage";
+import type { Subscriber } from "@/tracing";
 
 /**
  * Storage configuration for Kernl.
@@ -82,6 +83,12 @@ export interface KernlOptions {
    * Memory system configuration.
    */
   memory?: MemoryOptions;
+
+  /**
+   * Tracer for observability. Receives span and event data.
+   * Use CompositeTracer to fan out to multiple backends.
+   */
+  tracer?: Subscriber;
 }
 
 /**

package/src/mcp/http.ts

@@ -77,7 +77,6 @@ export class MCPServerStreamableHttp extends BaseMCPServer {
       throw e;
     }
 
-    this.logger.debug(`Connected to MCP server: ${this.id}`);
   }
 
   /**
@@ -107,7 +106,6 @@ export class MCPServerStreamableHttp extends BaseMCPServer {
     }
 
     const response = await this.session.listTools();
-    this.logger.debug(`Listed tools: ${JSON.stringify(response)}`);
     return ListToolsResultSchema.parse(response).tools;
   }
 
@@ -136,12 +134,6 @@ export class MCPServerStreamableHttp extends BaseMCPServer {
     );
 
     const parsed = CallToolResultSchema.parse(response);
-    const result = parsed.content;
-
-    this.logger.debug(
-      `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`,
-    );
-
-    return result as CallToolResultContent;
+    return parsed.content as CallToolResultContent;
   }
 }

package/src/mcp/sse.ts

@@ -66,8 +66,6 @@ export class MCPServerSSE extends BaseMCPServer {
       await this.close();
       throw e;
     }
-
-    this.logger.debug(`Connected to MCP server: ${this.id}`);
   }
 
   /**
@@ -83,7 +81,6 @@ export class MCPServerSSE extends BaseMCPServer {
     }
 
     const response = await this.session.listTools();
-    this.logger.debug(`Listed tools: ${JSON.stringify(response)}`);
     return ListToolsResultSchema.parse(response).tools;
   }
 
@@ -112,13 +109,7 @@ export class MCPServerSSE extends BaseMCPServer {
     );
 
     const parsed = CallToolResultSchema.parse(response);
-    const result = parsed.content;
-
-    this.logger.debug(
-      `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`,
-    );
-
-    return result as CallToolResultContent;
+    return parsed.content as CallToolResultContent;
   }
 
   /**

package/src/mcp/stdio.ts

@@ -62,8 +62,6 @@ export class MCPServerStdio extends BaseMCPServer {
       this.serverInitializeResult = {
         serverInfo: { name: this.id, version: "1.0.0" },
       } as InitializeResult;
-
-      this.logger.debug(`Connected to MCP server: ${this.id}`);
     } catch (e) {
       this.logger.error("Error initializing MCP server:", e);
       await this.close();
@@ -82,7 +80,6 @@ export class MCPServerStdio extends BaseMCPServer {
     }
 
     const response = await this.session.listTools();
-    this.logger.debug(`Listed tools: ${JSON.stringify(response)}`);
     return ListToolsResultSchema.parse(response).tools;
   }
 
@@ -111,13 +108,7 @@ export class MCPServerStdio extends BaseMCPServer {
     );
 
     const parsed = CallToolResultSchema.parse(response);
-    const result = parsed.content;
-
-    this.logger.debug(
-      `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`,
-    );
-
-    return result as CallToolResultContent;
+    return parsed.content as CallToolResultContent;
   }
 
   /**

package/src/task.ts

@@ -8,7 +8,6 @@ import type { Thread } from "@/thread";
  */
 export class Task<TContext = UnknownContext, TResult = unknown> {
   id: string /* unique identifier for this task (pid) */;
-  // tgid: string | null; /* task groupid */
   // prio: TaskPriority;
   instructions:
     | string

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

@@ -1060,6 +1060,286 @@ describe("Thread", () => {
     });
   });
 
+  describe("Event Sequencing", () => {
+    it("should assign incrementing seq values to all persisted events", async () => {
+      let callCount = 0;
+
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
+
+        if (callCount === 1) {
+          return {
+            content: [
+              {
+                kind: "message" as const,
+                id: "msg_1",
+                role: "assistant" as const,
+                content: [],
+              },
+              {
+                kind: "tool.call" as const,
+                toolId: "echo",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: JSON.stringify({ text: "test" }),
+              },
+            ],
+            finishReason: "stop",
+            usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+            warnings: [],
+          };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done!" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: { inputTokens: 4, outputTokens: 2, totalTokens: 6 },
+          warnings: [],
+        };
+      });
+
+      const echoTool = tool({
+        id: "echo",
+        description: "Echoes input",
+        parameters: z.object({ text: z.string() }),
+        execute: async (ctx, { text }) => `Echo: ${text}`,
+      });
+
+      const agent = new Agent({
+        id: "test",
+        name: "Test",
+        instructions: "Test agent",
+        model,
+        toolkits: [
+          new FunctionToolkit({ id: "test-tools", tools: [echoTool] }),
+        ],
+      });
+
+      const thread = new Thread({ agent, input: userMessage("test") });
+      await thread.execute();
+
+      const history = (thread as any).history as ThreadEvent[];
+
+      // Verify all events have seq values
+      for (const event of history) {
+        expect(event).toHaveProperty("seq");
+        expect(typeof event.seq).toBe("number");
+      }
+
+      // Verify seq values increment: 0, 1, 2, 3, 4
+      const seqValues = history.map((e) => e.seq);
+      expect(seqValues).toEqual([0, 1, 2, 3, 4]);
+    });
+
+    it("should assign consistent tid to all events in a thread", async () => {
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_1",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Hello" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+          warnings: [],
+        };
+      });
+
+      const agent = new Agent({
+        id: "test",
+        name: "Test",
+        instructions: "Test agent",
+        model,
+      });
+
+      const thread = new Thread({ agent, input: userMessage("test") });
+      await thread.execute();
+
+      const history = (thread as any).history as ThreadEvent[];
+      const threadId = thread.tid;
+
+      // All events should have the same tid as the thread
+      for (const event of history) {
+        expect(event).toHaveProperty("tid");
+        expect(event.tid).toBe(threadId);
+      }
+    });
+
+    it("should assign timestamps to all events", async () => {
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_1",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Hello" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+          warnings: [],
+        };
+      });
+
+      const agent = new Agent({
+        id: "test",
+        name: "Test",
+        instructions: "Test agent",
+        model,
+      });
+
+      const thread = new Thread({ agent, input: userMessage("test") });
+      await thread.execute();
+
+      const history = (thread as any).history as ThreadEvent[];
+
+      for (const event of history) {
+        expect(event).toHaveProperty("timestamp");
+        expect(event.timestamp).toBeInstanceOf(Date);
+      }
+    });
+
+    it("should generate event ids in expected format", async () => {
+      let callCount = 0;
+
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        callCount++;
+
+        if (callCount === 1) {
+          return {
+            content: [
+              {
+                kind: "message" as const,
+                id: "msg_1",
+                role: "assistant" as const,
+                content: [],
+              },
+              {
+                kind: "tool.call" as const,
+                toolId: "simple",
+                state: IN_PROGRESS,
+                callId: "call_1",
+                arguments: "{}",
+              },
+            ],
+            finishReason: "stop",
+            usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+            warnings: [],
+          };
+        }
+
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_2",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Done" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+          warnings: [],
+        };
+      });
+
+      const simpleTool = tool({
+        id: "simple",
+        description: "Simple tool",
+        parameters: undefined,
+        execute: async () => "result",
+      });
+
+      const agent = new Agent({
+        id: "test",
+        name: "Test",
+        instructions: "Test agent",
+        model,
+        toolkits: [
+          new FunctionToolkit({ id: "test-tools", tools: [simpleTool] }),
+        ],
+      });
+
+      const thread = new Thread({ agent, input: userMessage("test") });
+      await thread.execute();
+
+      const history = (thread as any).history as ThreadEvent[];
+
+      // Messages should have id format "message:{original_id}"
+      const messages = history.filter((e) => e.kind === "message");
+      for (const msg of messages) {
+        expect(msg.id).toMatch(/^message:/);
+      }
+
+      // Tool calls use callId (not id), so tevent falls back to randomID()
+      const toolCalls = history.filter((e) => e.kind === "tool.call");
+      for (const tc of toolCalls) {
+        expect(tc.id).toBeDefined();
+        expect(typeof tc.id).toBe("string");
+      }
+
+      // Tool results also use callId, so tevent falls back to randomID()
+      const toolResults = history.filter((e) => e.kind === "tool.result");
+      for (const tr of toolResults) {
+        expect(tr.id).toBeDefined();
+        expect(typeof tr.id).toBe("string");
+      }
+    });
+
+    it("should yield sequenced events during streaming", async () => {
+      const model = createMockModel(async (req: LanguageModelRequest) => {
+        return {
+          content: [
+            {
+              kind: "message" as const,
+              id: "msg_1",
+              role: "assistant" as const,
+              content: [{ kind: "text" as const, text: "Hello" }],
+            },
+          ],
+          finishReason: "stop",
+          usage: { inputTokens: 2, outputTokens: 2, totalTokens: 4 },
+          warnings: [],
+        };
+      });
+
+      const agent = new Agent({
+        id: "test",
+        name: "Test",
+        instructions: "Test agent",
+        model,
+      });
+
+      const thread = new Thread({ agent, input: userMessage("test") });
+
+      const events: any[] = [];
+      for await (const event of thread.stream()) {
+        events.push(event);
+      }
+
+      // Find the complete message event (not deltas)
+      const messageEvent = events.find(
+        (e) => e.kind === "message" && e.role === "assistant",
+      );
+
+      expect(messageEvent).toBeDefined();
+      expect(messageEvent).toHaveProperty("seq");
+      expect(messageEvent).toHaveProperty("tid");
+      expect(messageEvent).toHaveProperty("timestamp");
+    });
+  });
+
   describe("Final Output Parsing", () => {
     it("should return text output when output is 'text'", async () => {
       const model = createMockModel(async (req: LanguageModelRequest) => {