kernl 0.2.0 → 0.6.0

package/dist/storage/in-memory.js

@@ -0,0 +1,283 @@
+/**
+ * In-memory storage implementation for Kernl.
+ *
+ * Pure domain-level - no codecs, schemas, or DB records.
+ *
+ * Defined here so that it can be used as default and for testing.
+ */
+import { Thread } from "../thread";
+import { Context } from "../context";
+import { STOPPED } from "@kernl-sdk/protocol";
+import { UnimplementedError } from "@kernl-sdk/shared/lib";
+/**
+ * In-memory storage implementation.
+ */
+export class InMemoryStorage {
+    threads;
+    constructor() {
+        this.threads = new InMemoryThreadStore();
+    }
+    bind(registries) {
+        this.threads.bind(registries);
+    }
+    async transaction(fn) {
+        throw new UnimplementedError("Transactions not supported in in-memory storage");
+    }
+    async init() {
+        // no-op
+    }
+    async close() {
+        // no-op
+    }
+    async migrate() {
+        // no-op
+    }
+}
+/**
+ * In-memory thread store implementation.
+ */
+export class InMemoryThreadStore {
+    threads = new Map();
+    events = new Map(); // tid -> events
+    registries = null;
+    bind(registries) {
+        this.registries = registries;
+    }
+    async get(tid, include) {
+        const data = this.threads.get(tid);
+        if (!data)
+            return null;
+        const history = include?.history
+            ? this.filterHistory(tid, include.history)
+            : [];
+        try {
+            return this.hydrate(data, history);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async list(options) {
+        let threads = Array.from(this.threads.values());
+        // Apply filters
+        if (options?.filter) {
+            threads = this.applyFilters(threads, options.filter);
+        }
+        // Apply sorting
+        threads = this.applySorting(threads, options?.order);
+        // Apply pagination
+        if (options?.offset)
+            threads = threads.slice(options.offset);
+        if (options?.limit)
+            threads = threads.slice(0, options.limit);
+        return threads
+            .map((data) => {
+            try {
+                return this.hydrate(data, []);
+            }
+            catch (error) {
+                // Skip threads with non-existent agent/model (graceful degradation)
+                return null;
+            }
+        })
+            .filter((thread) => thread !== null);
+    }
+    async insert(thread) {
+        const now = new Date();
+        const data = {
+            tid: thread.id,
+            namespace: thread.namespace,
+            agentId: thread.agentId,
+            model: thread.model,
+            context: thread.context ?? {},
+            tick: thread.tick ?? 0,
+            state: thread.state ?? STOPPED,
+            parentTaskId: thread.parentTaskId ?? null,
+            metadata: thread.metadata ?? null,
+            createdAt: thread.createdAt ?? now,
+            updatedAt: thread.updatedAt ?? now,
+        };
+        this.threads.set(thread.id, data);
+        this.events.set(thread.id, []);
+        return this.hydrate(data, []);
+    }
+    async update(tid, patch) {
+        const data = this.threads.get(tid);
+        if (!data)
+            throw new Error(`Thread ${tid} not found`);
+        if (patch.tick !== undefined)
+            data.tick = patch.tick;
+        if (patch.state !== undefined)
+            data.state = patch.state;
+        if (patch.context !== undefined) {
+            // Store raw context value, not the Context wrapper.
+            data.context = patch.context.context;
+        }
+        if (patch.metadata !== undefined)
+            data.metadata = patch.metadata;
+        data.updatedAt = new Date();
+        return this.hydrate(data, []);
+    }
+    async delete(tid) {
+        this.threads.delete(tid);
+        this.events.delete(tid);
+    }
+    async history(tid, opts) {
+        return this.filterHistory(tid, opts);
+    }
+    async append(events) {
+        if (events.length === 0)
+            return;
+        // Group by tid
+        const byThread = new Map();
+        for (const event of events) {
+            if (!byThread.has(event.tid))
+                byThread.set(event.tid, []);
+            byThread.get(event.tid).push(event);
+        }
+        // Append to each thread's event log (idempotent on event.id)
+        for (const [tid, newEvents] of Array.from(byThread.entries())) {
+            let existing = this.events.get(tid);
+            if (!existing) {
+                existing = [];
+                this.events.set(tid, existing);
+            }
+            const existingIds = new Set(existing.map((e) => e.id));
+            for (const event of newEvents) {
+                if (!existingIds.has(event.id)) {
+                    existing.push(event);
+                }
+            }
+            // Keep sorted by seq
+            existing.sort((a, b) => a.seq - b.seq);
+        }
+    }
+    /**
+     * Hydrate a Thread instance from in-memory data.
+     */
+    hydrate(data, history) {
+        if (!this.registries) {
+            throw new Error("Registries must be bound before hydrating threads (call bind() first)");
+        }
+        const agent = this.registries.agents.get(data.agentId);
+        const model = this.registries.models.get(data.model);
+        if (!agent || !model) {
+            throw new Error(`Thread ${data.tid} references non-existent agent/model (agent: ${data.agentId}, model: ${data.model})`);
+        }
+        return new Thread({
+            agent,
+            tid: data.tid,
+            context: new Context(data.namespace, data.context),
+            model,
+            history,
+            tick: data.tick,
+            state: data.state,
+            namespace: data.namespace,
+            task: null, // TODO: load from TaskStore when it exists
+            metadata: data.metadata,
+            storage: this, // pass storage reference so resumed thread can persist
+            persisted: true,
+        });
+    }
+    /**
+     * Filter and sort event history based on options.
+     */
+    filterHistory(tid, opts) {
+        let events = this.events.get(tid) ?? [];
+        // Handle boolean flag: true = all events, false = no events
+        if (typeof opts === "boolean") {
+            return opts ? [...events] : [];
+        }
+        // No options provided = return all events
+        if (opts === undefined) {
+            return [...events];
+        }
+        // Apply filters
+        if (opts.after !== undefined) {
+            events = events.filter((e) => e.seq > opts.after);
+        }
+        if (opts.kinds && opts.kinds.length > 0) {
+            const kinds = new Set(opts.kinds);
+            events = events.filter((e) => kinds.has(e.kind));
+        }
+        // Clone before sorting/slicing to avoid mutating the original
+        events = [...events];
+        // Apply ordering
+        if (opts.order === "desc") {
+            events.reverse();
+        }
+        // Apply limit
+        if (opts.limit !== undefined) {
+            events = events.slice(0, opts.limit);
+        }
+        return events;
+    }
+    /**
+     * Apply filters to thread list.
+     */
+    applyFilters(threads, filter) {
+        return threads.filter((thread) => {
+            // Filter by namespace
+            if (filter.namespace !== undefined) {
+                if (thread.namespace !== filter.namespace)
+                    return false;
+            }
+            // Filter by state
+            if (filter.state !== undefined) {
+                if (Array.isArray(filter.state)) {
+                    if (!filter.state.includes(thread.state))
+                        return false;
+                }
+                else {
+                    if (thread.state !== filter.state)
+                        return false;
+                }
+            }
+            // Filter by agentId
+            if (filter.agentId !== undefined) {
+                if (thread.agentId !== filter.agentId)
+                    return false;
+            }
+            // Filter by parentTaskId
+            if (filter.parentTaskId !== undefined) {
+                if (thread.parentTaskId !== filter.parentTaskId)
+                    return false;
+            }
+            // Filter by createdAfter
+            if (filter.createdAfter !== undefined) {
+                if (thread.createdAt <= filter.createdAfter)
+                    return false;
+            }
+            // Filter by createdBefore
+            if (filter.createdBefore !== undefined) {
+                if (thread.createdAt >= filter.createdBefore)
+                    return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Apply sorting to thread list.
+     */
+    applySorting(threads, order) {
+        if (!order) {
+            // Default: most recent first
+            return threads.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        }
+        return threads.sort((a, b) => {
+            // Sort by createdAt first if specified
+            if (order.createdAt) {
+                const diff = a.createdAt.getTime() - b.createdAt.getTime();
+                if (diff !== 0) {
+                    return order.createdAt === "asc" ? diff : -diff;
+                }
+            }
+            // Then by updatedAt if specified
+            if (order.updatedAt) {
+                const diff = a.updatedAt.getTime() - b.updatedAt.getTime();
+                return order.updatedAt === "asc" ? diff : -diff;
+            }
+            return 0;
+        });
+    }
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Storage contracts for Kernl.
+ *
+ * Core owns these interfaces; storage packages implement them.
+ * (must be defined here to avoid circular deps)
+ */
+export type { NewThread, ThreadUpdate, ThreadFilter, ThreadHistoryOptions, ThreadInclude, SortOrder, ThreadListOptions, ThreadStore, } from "./thread";
+export type { Transaction, KernlStorage } from "./base";
+export { InMemoryStorage, InMemoryThreadStore } from "./in-memory";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,WAAW,GACZ,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1,7 @@
+/**
+ * Storage contracts for Kernl.
+ *
+ * Core owns these interfaces; storage packages implement them.
+ * (must be defined here to avoid circular deps)
+ */
+export { InMemoryStorage, InMemoryThreadStore } from "./in-memory";

package/dist/storage/thread.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Thread storage contracts.
+ */
+import type { Thread } from "../thread";
+import type { Context } from "../context";
+import type { ThreadEvent, ThreadState } from "../types/thread";
+/**
+ * Thread persistence store.
+ */
+export interface ThreadStore {
+    /**
+     * Get a thread by id.
+     *
+     * Optionally include the thread_events.
+     */
+    get(tid: string, include?: ThreadInclude): Promise<Thread | null>;
+    /**
+     * List threads matching the filter.
+     */
+    list(options?: ThreadListOptions): Promise<Thread[]>;
+    /**
+     * Insert a new thread into the store.
+     */
+    insert(thread: NewThread): Promise<Thread>;
+    /**
+     * Update thread runtime state (tick, state, metadata).
+     *
+     * Does NOT mutate the event log, which is append-only.
+     */
+    update(tid: string, patch: ThreadUpdate): Promise<Thread>;
+    /**
+     * Delete a thread and cascade to thread_events.
+     */
+    delete(tid: string): Promise<void>;
+    /**
+     * Get the event history for a thread.
+     */
+    history(tid: string, options?: ThreadHistoryOptions): Promise<ThreadEvent[]>;
+    /**
+     * Append events to the thread history.
+     *
+     * Semantics:
+     * - Guaranteed per-thread ordering via a monotonically increasing `seq`.
+     * - Idempotent on `(tid, event.id)`: duplicate ids MUST NOT create duplicate rows.
+     * - Events maintain insertion order.
+     *
+     * Note:
+     * - Thread class manages monotonic seq and timestamp assignment.
+     */
+    append(events: ThreadEvent[]): Promise<void>;
+}
+/**
+ * Input for creating a new thread.
+ */
+export interface NewThread {
+    id: string;
+    namespace: string;
+    agentId: string;
+    model: string;
+    context?: unknown;
+    tick?: number;
+    state?: ThreadState;
+    parentTaskId?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Partial update for thread runtime state.
+ *
+ * Only mutable fields are exposed (tick, state, context, metadata).
+ */
+export interface ThreadUpdate {
+    tick?: number;
+    state?: ThreadState;
+    context?: Context;
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * Filter for listing threads.
+ */
+export interface ThreadFilter {
+    namespace?: string;
+    state?: ThreadState | ThreadState[];
+    agentId?: string;
+    parentTaskId?: string;
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+/**
+ * Options for querying thread history.
+ */
+export interface ThreadHistoryOptions {
+    after?: number;
+    limit?: number;
+    order?: "asc" | "desc";
+    kinds?: string[];
+}
+/**
+ * Include options for eager loading related data.
+ */
+export interface ThreadInclude {
+    history?: boolean | ThreadHistoryOptions;
+}
+/**
+ * Sort order direction.
+ */
+export type SortOrder = "asc" | "desc";
+/**
+ * Options for listing threads.
+ */
+export interface ThreadListOptions {
+    filter?: ThreadFilter;
+    include?: ThreadInclude;
+    order?: {
+        createdAt?: SortOrder;
+        updatedAt?: SortOrder;
+    };
+    limit?: number;
+    offset?: number;
+    cursor?: string;
+}
+//# sourceMappingURL=thread.d.ts.map

package/dist/storage/thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/storage/thread.ts"],"names":[],"mappings":"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"}

package/dist/storage/thread.js

@@ -0,0 +1,4 @@
+/**
+ * Thread storage contracts.
+ */
+export {};

package/dist/task.d.ts

@@ -6,10 +6,11 @@ import type { Thread } from "./thread";
  * Analogous to task_struct in the Linux kernel.
  */
 export declare class Task<TContext = UnknownContext, TResult = unknown> {
-    pid: string;
+    id: string;
     instructions: string | ((context: Context<TContext>) => string);
     state: TaskState;
     owner: Agent<TContext>;
+    namespace: string;
     context: Context<TContext>;
     /**
      * Might want the ability to pick up a new thread of execution from a compressed task checkpoint instead of including
@@ -19,12 +20,13 @@ export declare class Task<TContext = UnknownContext, TResult = unknown> {
     threads: Thread<TContext>[];
     current: Thread<TContext> | null;
     result: TResult | null;
-    constructor(init: {
-        pid: string;
+    constructor(options: {
+        id: string;
         instructions: string | ((context: Context<TContext>) => string);
         state: TaskState;
         owner: Agent<TContext>;
         context: Context<TContext>;
+        namespace?: string;
     });
 }
 /**

package/dist/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,qBAAa,IAAI,CAAC,QAAQ,GAAG,cAAc,EAAE,OAAO,GAAG,OAAO;IAC5D,GAAG,EAAE,MAAM,CAAoD;IAG/D,YAAY,EACR,MAAM,GACN,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAA4B;IAExE,KAAK,EAAE,SAAS,CAAiC;IACjD,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAA2C;IAEjE,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAA0D;IAIpF;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA6C;IACxE,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAyC;IACzE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAgC;gBAQ1C,IAAI,EAAE;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,YAAY,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAAC;QAChE,KAAK,EAAE,SAAS,CAAC;QACjB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACvB,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;KAC5B;CAUF;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB;;;;OAIG;IACH,OAAO,YAAY;IAEnB;;;;;;;;;;OAUG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;;;OASG;IACH,eAAe,oBAAoB;IAEnC;;;;;;;OAOG;IACH,OAAO,YAAY;IAEnB;;;;;;;OAOG;IACH,MAAM,WAAW;IAEjB;;;OAGG;IACH,IAAI,SAAS;CACd"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,qBAAa,IAAI,CAAC,QAAQ,GAAG,cAAc,EAAE,OAAO,GAAG,OAAO;IAC5D,EAAE,EAAE,MAAM,CAA6C;IAGvD,YAAY,EACR,MAAM,GACN,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAA4B;IAExE,KAAK,EAAE,SAAS,CAAiC;IACjD,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAA2C;IACjE,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAA0D;IAIpF;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA6C;IACxE,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAyC;IACzE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAgC;gBAQ1C,OAAO,EAAE;QACnB,EAAE,EAAE,MAAM,CAAC;QACX,YAAY,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAAC;QAChE,KAAK,EAAE,SAAS,CAAC;QACjB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACvB,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CAWF;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB;;;;OAIG;IACH,OAAO,YAAY;IAEnB;;;;;;;;;;OAUG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;;;OASG;IACH,eAAe,oBAAoB;IAEnC;;;;;;;OAOG;IACH,OAAO,YAAY;IAEnB;;;;;;;OAOG;IACH,MAAM,WAAW;IAEjB;;;OAGG;IACH,IAAI,SAAS;CACd"}

package/dist/task.js

@@ -3,13 +3,14 @@
  * Analogous to task_struct in the Linux kernel.
  */
 export class Task {
-    pid;
+    id;
     // tgid: string | null; /* task groupid */
     // prio: TaskPriority;
     instructions;
     // sched: TaskSched; /* scheduling (timers, timeouts, deadlines) */
     state;
     owner;
+    namespace;
     context;
     // cred: Credentials; /* Effective (overridable) subjective task credentials (COW): */
     // realcred: Credentials; /* Objective and real subjective task credentials (COW): */
@@ -25,13 +26,14 @@ export class Task {
     // TODO: Deferred fields for later implementation
     // tgid: string;              // Thread group ID
     // limits: TaskLimits;        // Resource limits (max ticks, tokens, timeout)
-    // nsproxy: NamespaceProxy;   // Namespace isolation
-    constructor(init) {
-        this.pid = init.pid;
-        this.instructions = init.instructions;
-        this.state = init.state;
-        this.owner = init.owner;
-        this.context = init.context;
+    // nsproxy: NamespaceProxy;   // Namespace isolation (partially implemented via namespace string)
+    constructor(options) {
+        this.id = options.id;
+        this.instructions = options.instructions;
+        this.state = options.state;
+        this.owner = options.owner;
+        this.context = options.context;
+        this.namespace = options.namespace ?? "kernl";
         this.threads = [];
         this.current = null;
         this.result = null;

package/dist/thread/__tests__/fixtures/mock-model.d.ts

@@ -1,7 +1,6 @@
-import type { LanguageModel, LanguageModelRequest, LanguageModelResponse } from "@kernl-sdk/protocol";
 /**
  * Creates a mock LanguageModel that automatically implements streaming
  * based on the generate() implementation.
  */
-export declare function createMockModel(generateFn: (req: LanguageModelRequest) => Promise<LanguageModelResponse>): LanguageModel;
+export declare function createMockModel(generateFn: any): any;
 //# sourceMappingURL=mock-model.d.ts.map

package/dist/thread/__tests__/fixtures/mock-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-model.d.ts","sourceRoot":"","sources":["../../../../src/thread/__tests__/fixtures/mock-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EAGtB,MAAM,qBAAqB,CAAC;AA+C7B;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,qBAAqB,CAAC,GACxE,aAAa,CAWf"}
+{"version":3,"file":"mock-model.d.ts","sourceRoot":"","sources":["../../../../src/thread/__tests__/fixtures/mock-model.ts"],"names":[],"mappings":"AAqDA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,GAAG,GAAG,GAAG,CAWpD"}

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

@@ -40,7 +40,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                     ],
                 },
             ];
-            const thread = new Thread(kernl, agent, input);
+            const thread = new Thread({ agent, input });
             const events = [];
             for await (const event of thread.stream()) {
                 events.push(event);
@@ -89,7 +89,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                     content: [{ kind: "text", text: "Count to 3" }],
                 },
             ];
-            const thread = new Thread(kernl, agent, input);
+            const thread = new Thread({ agent, input });
             const streamEvents = [];
             for await (const event of thread.stream()) {
                 streamEvents.push(event);
@@ -150,7 +150,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                     content: [{ kind: "text", text: "What is 25 + 17?" }],
                 },
             ];
-            const thread = new Thread(kernl, agent, input);
+            const thread = new Thread({ agent, input });
             const events = [];
             for await (const event of thread.stream()) {
                 events.push(event);
@@ -184,6 +184,74 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
             expect(textContent).toBeDefined();
             expect(textContent.text).toContain("42");
         }, 30000);
+        it("should properly encode tool results with matching callIds for multi-turn", async () => {
+            const multiplyTool = tool({
+                id: "multiply",
+                name: "multiply",
+                description: "Multiply two numbers",
+                parameters: z.object({
+                    a: z.number().describe("First number"),
+                    b: z.number().describe("Second number"),
+                }),
+                execute: async (ctx, { a, b }) => {
+                    return a * b;
+                },
+            });
+            const toolkit = new Toolkit({
+                id: "math",
+                tools: [multiplyTool],
+            });
+            const agent = new Agent({
+                id: "test-multi-turn",
+                name: "Test Multi-Turn Agent",
+                instructions: "You are a helpful assistant that can do math.",
+                model,
+                toolkits: [toolkit],
+            });
+            const input = [
+                {
+                    kind: "message",
+                    id: "msg-1",
+                    role: "user",
+                    content: [{ kind: "text", text: "What is 7 times 6?" }],
+                },
+            ];
+            const thread = new Thread({ agent, input });
+            const events = [];
+            // Collect all events from the stream
+            for await (const event of thread.stream()) {
+                events.push(event);
+            }
+            // Find the tool call and result
+            const toolCalls = events.filter((e) => e.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];
+            const multiplyResult = toolResults[0];
+            // Verify callId matches between tool call and result
+            expect(multiplyCall.callId).toBe(multiplyResult.callId);
+            expect(multiplyCall.toolId).toBe("multiply");
+            expect(multiplyResult.toolId).toBe("multiply");
+            // Verify the tool result has the correct structure
+            expect(multiplyResult.callId).toBeDefined();
+            expect(typeof multiplyResult.callId).toBe("string");
+            expect(multiplyResult.callId.length).toBeGreaterThan(0);
+            // Verify history contains both with matching callIds
+            const history = thread.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");
+            expect(historyToolCall).toBeDefined();
+            expect(historyToolResult).toBeDefined();
+            expect(historyToolCall.callId).toBe(historyToolResult.callId);
+            // Verify final response uses the tool result
+            const messages = events.filter((e) => e.kind === "message");
+            const assistantMessage = messages.find((m) => m.role === "assistant");
+            expect(assistantMessage).toBeDefined();
+            const textContent = assistantMessage.content.find((c) => c.kind === "text");
+            expect(textContent).toBeDefined();
+            expect(textContent.text).toContain("42");
+        }, 30000);
     });
     describe("execute()", () => {
         it("should consume stream and return final response", async () => {
@@ -201,7 +269,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                     content: [{ kind: "text", text: "Say 'Testing' and nothing else." }],
                 },
             ];
-            const thread = new Thread(kernl, agent, input);
+            const thread = new Thread({ agent, input });
             const result = await thread.execute();
             // Should have a response
             expect(result.response).toBeDefined();
@@ -235,7 +303,7 @@ describe.skipIf(SKIP_INTEGRATION_TESTS)("Thread streaming integration", () => {
                     ],
                 },
             ];
-            const thread = new Thread(kernl, agent, input);
+            const thread = new Thread({ agent, input });
             const result = await thread.execute();
             // Response should be validated and parsed
             expect(result.response).toBeDefined();

package/dist/thread/__tests__/namespace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=namespace.test.d.ts.map

package/dist/thread/__tests__/namespace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.test.d.ts","sourceRoot":"","sources":["../../../src/thread/__tests__/namespace.test.ts"],"names":[],"mappings":""}