kernl 0.2.1 → 0.6.0

package/dist/api/pagination/offset.d.ts

@@ -0,0 +1,42 @@
+import { AbstractPage, type PageParamsBase } from "./base";
+export interface OffsetPageParams extends PageParamsBase {
+    /**
+     * Number of items to skip from the beginning of the collection.
+     */
+    offset?: number;
+}
+export interface OffsetPageResponse<T> {
+    data: T[];
+    offset: number;
+    limit: number;
+    /**
+     * Optional total count when the underlying store can provide it.
+     */
+    total?: number;
+}
+export declare class OffsetPage<T, TParams extends OffsetPageParams = OffsetPageParams> extends AbstractPage<T, TParams, OffsetPageResponse<T>> {
+    data: T[];
+    offset: number;
+    limit: number;
+    total?: number;
+    constructor(args: {
+        params: TParams;
+        response: OffsetPageResponse<T>;
+        loader: (params: TParams) => Promise<OffsetPageResponse<T>>;
+    });
+    /**
+     * All items contained in this page.
+     */
+    get items(): T[];
+    /**
+     * True if this is the last page in the sequence.
+     *
+     * When `last` is true, `next()` will return null.
+     */
+    get last(): boolean;
+    /**
+     * Fetch the next page, or null if there is no next page.
+     */
+    next(): Promise<this | null>;
+}
+//# sourceMappingURL=offset.d.ts.map

package/dist/api/pagination/offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../../../src/api/pagination/offset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAE3D,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,UAAU,CACrB,CAAC,EACD,OAAO,SAAS,gBAAgB,GAAG,gBAAgB,CACnD,SAAQ,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IACvD,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;gBAEH,IAAI,EAAE;QAChB,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAChC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;KAC7D;IAQD;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,EAAE,CAEf;IAED;;;;OAIG;IACH,IAAI,IAAI,IAAI,OAAO,CAWlB;IAED;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;CAoBnC"}

package/dist/api/pagination/offset.js

@@ -0,0 +1,55 @@
+import { AbstractPage } from "./base";
+export class OffsetPage extends AbstractPage {
+    data;
+    offset;
+    limit;
+    total;
+    constructor(args) {
+        super(args);
+        this.data = args.response.data ?? [];
+        this.offset = args.response.offset;
+        this.limit = args.response.limit;
+        this.total = args.response.total;
+    }
+    /**
+     * All items contained in this page.
+     */
+    get items() {
+        return this.data;
+    }
+    /**
+     * True if this is the last page in the sequence.
+     *
+     * When `last` is true, `next()` will return null.
+     */
+    get last() {
+        if (this.data.length === 0) {
+            return true;
+        }
+        const next = (this.offset ?? 0) + (this.limit ?? 0);
+        if (this.total != null && next >= this.total) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Fetch the next page, or null if there is no next page.
+     */
+    async next() {
+        if (this.last) {
+            return null;
+        }
+        const next = (this.offset ?? 0) + (this.limit ?? 0);
+        const nextParams = {
+            ...this.params,
+            offset: next,
+        };
+        const res = await this.loader(nextParams);
+        const page = new OffsetPage({
+            params: nextParams,
+            response: res,
+            loader: this.loader,
+        });
+        return page;
+    }
+}

package/dist/api/resources/threads/events.d.ts

@@ -0,0 +1,21 @@
+import type { ThreadStore } from "../../../storage";
+import type { MThreadEvent } from "../../../api/models";
+/**
+ * Events subresource for threads.
+ *
+ * Provides access to the event log for an individual thread, filtered down to
+ * events that make sense to surface to callers (messages, tool calls/results, etc.).
+ */
+export declare class RThreadEvents {
+    private readonly store;
+    constructor(store: ThreadStore);
+    /**
+     * List events for a thread.
+     *
+     * Returns only public events – internal system events are filtered out.
+     *
+     * @param tid - Thread ID
+     */
+    list(tid: string): Promise<MThreadEvent[]>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/api/resources/threads/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../src/api/resources/threads/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD;;;;;GAKG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,WAAW;IAE/C;;;;;;OAMG;IACG,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;CAIjD"}

package/dist/api/resources/threads/events.js

@@ -0,0 +1,24 @@
+import { isPublicEvent } from "../../../thread/utils";
+/**
+ * Events subresource for threads.
+ *
+ * Provides access to the event log for an individual thread, filtered down to
+ * events that make sense to surface to callers (messages, tool calls/results, etc.).
+ */
+export class RThreadEvents {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * List events for a thread.
+     *
+     * Returns only public events – internal system events are filtered out.
+     *
+     * @param tid - Thread ID
+     */
+    async list(tid) {
+        const events = await this.store.history(tid);
+        return events.filter(isPublicEvent).map((e) => e);
+    }
+}

package/dist/api/resources/threads/index.d.ts

@@ -0,0 +1,4 @@
+export { RThreads } from "./threads";
+export { RThreadEvents } from "./events";
+export type { RThreadsListParams, RThreadGetOptions, RThreadHistoryParams, RThreadCreateParams, RThreadUpdateParams, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/resources/threads/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/resources/threads/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

package/dist/api/resources/threads/index.js

@@ -0,0 +1,2 @@
+export { RThreads } from "./threads";
+export { RThreadEvents } from "./events";

package/dist/api/resources/threads/threads.d.ts

@@ -0,0 +1,57 @@
+import type { ThreadStore } from "../../../storage";
+import type { MThread, MThreadEvent } from "../../../api/models";
+import { CursorPage } from "../../../api/pagination/cursor";
+import { RThreadEvents } from "./events";
+import type { RThreadCreateParams, RThreadGetOptions, RThreadHistoryParams, RThreadsListParams, RThreadUpdateParams } from "./types";
+/**
+ * Threads resource.
+ *
+ * Provides a structured API for listing, inspecting, and deleting threads.
+ */
+export declare class RThreads {
+    private readonly store;
+    readonly events: RThreadEvents;
+    constructor(store: ThreadStore);
+    /**
+     * Get a single thread by ID.
+     *
+     * When `options.history` is set, the returned thread will include a
+     * `history` field containing public events for that thread.
+     */
+    get(tid: string, options?: RThreadGetOptions): Promise<MThread | null>;
+    /**
+     * Create a new thread.
+     */
+    create(params: RThreadCreateParams): Promise<MThread>;
+    /**
+     * List threads with optional filtering and cursor-based pagination.
+     *
+     * @example
+     * ```ts
+     * const threads = await kernl.threads.list({ limit: 20 });
+     *
+     * for await (const thread of threads) {
+     *   console.log(thread.tid);
+     * }
+     * ```
+     */
+    list(params?: RThreadsListParams): Promise<CursorPage<MThread, RThreadsListParams>>;
+    /**
+     * Delete a thread and all associated events.
+     */
+    delete(tid: string): Promise<void>;
+    /**
+     * Convenience wrapper around `events.list()` for fetching a thread's history.
+     *
+     * History is returned in descending sequence order by default (latest first).
+     */
+    history(tid: string, params?: RThreadHistoryParams): Promise<MThreadEvent[]>;
+    /**
+     * Update mutable thread fields.
+     *
+     * Currently only supports updating the human-readable `title`, which is
+     * stored in thread metadata as `metadata.title`.
+     */
+    update(tid: string, patch: RThreadUpdateParams): Promise<MThread | null>;
+}
+//# sourceMappingURL=threads.d.ts.map

package/dist/api/resources/threads/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../../../../src/api/resources/threads/threads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAGZ,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,UAAU,EAA2B,MAAM,yBAAyB,CAAC;AAE9E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAGjB;;;;GAIG;AACH,qBAAa,QAAQ;IAGP,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;gBAEF,KAAK,EAAE,WAAW;IAI/C;;;;;OAKG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAgB5E;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAqC3D;;;;;;;;;;;OAWG;IACG,IAAI,CACR,MAAM,GAAE,kBAAuB,GAC9B,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;IAkDnD;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC;;;;OAIG;IACG,OAAO,CACX,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,YAAY,EAAE,CAAC;IAY1B;;;;;OAKG;IACG,MAAM,CACV,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;CAyD3B"}

package/dist/api/resources/threads/threads.js

@@ -0,0 +1,199 @@
+import { isPublicEvent } from "../../../thread/utils";
+import { Context } from "../../../context";
+import { randomID } from "@kernl-sdk/shared/lib";
+import { RUNNING } from "@kernl-sdk/protocol";
+import { CursorPage } from "../../../api/pagination/cursor";
+import { RThreadEvents } from "./events";
+import { MThreadCodec, ThreadsFilterCodec, ThreadsOrderCodec } from "./utils";
+/**
+ * Threads resource.
+ *
+ * Provides a structured API for listing, inspecting, and deleting threads.
+ */
+export class RThreads {
+    store;
+    events;
+    constructor(store) {
+        this.store = store;
+        this.events = new RThreadEvents(store);
+    }
+    /**
+     * Get a single thread by ID.
+     *
+     * When `options.history` is set, the returned thread will include a
+     * `history` field containing public events for that thread.
+     */
+    async get(tid, options) {
+        const thread = await this.store.get(tid);
+        if (!thread)
+            return null;
+        const model = MThreadCodec.encode(thread);
+        if (options?.history) {
+            const historyParams = options.history === true ? undefined : options.history;
+            const history = await this.history(tid, historyParams);
+            model.history = history; // attach history lazily so callers can opt-in.
+        }
+        return model;
+    }
+    /**
+     * Create a new thread.
+     */
+    async create(params) {
+        const now = new Date();
+        const tid = params.tid ?? `tid_${randomID()}`;
+        const namespace = params.namespace ?? "kernl";
+        // merge caller-supplied metadata with optional title
+        const baseMetadata = {
+            ...(params.metadata ?? {}),
+        };
+        if (params.title !== undefined) {
+            const trimmed = params.title.trim();
+            if (trimmed) {
+                baseMetadata.title = trimmed;
+            }
+            else {
+                delete baseMetadata.title;
+            }
+        }
+        const metadata = Object.keys(baseMetadata).length > 0 ? baseMetadata : null;
+        const thread = await this.store.insert({
+            id: tid,
+            namespace,
+            agentId: params.agentId,
+            model: `${params.model.provider}/${params.model.modelId}`,
+            context: params.context,
+            parentTaskId: params.parentTaskId ?? null,
+            metadata,
+            createdAt: now,
+            updatedAt: now,
+        });
+        return MThreadCodec.encode(thread);
+    }
+    /**
+     * List threads with optional filtering and cursor-based pagination.
+     *
+     * @example
+     * ```ts
+     * const threads = await kernl.threads.list({ limit: 20 });
+     *
+     * for await (const thread of threads) {
+     *   console.log(thread.tid);
+     * }
+     * ```
+     */
+    async list(params = {}) {
+        const loader = async (p) => {
+            const offset = p.cursor ? Number(p.cursor) : 0;
+            const limit = p.limit;
+            const effectiveLimit = limit !== undefined ? limit + 1 : undefined;
+            const filter = ThreadsFilterCodec.encode(p);
+            const order = ThreadsOrderCodec.encode(p.order);
+            const options = {
+                filter,
+                order,
+                limit: effectiveLimit,
+                offset,
+            };
+            const threads = await this.store.list(options);
+            if (limit === undefined) {
+                // No limit requested → treat as a single, non-paginated page.
+                const data = threads.map((t) => MThreadCodec.encode(t));
+                return {
+                    data,
+                    next: null,
+                    last: true,
+                };
+            }
+            const hasExtra = threads.length > limit;
+            const pageThreads = hasExtra ? threads.slice(0, limit) : threads;
+            const data = pageThreads.map((t) => MThreadCodec.encode(t));
+            const nextOffset = offset + data.length;
+            const last = !hasExtra || data.length === 0;
+            const next = last ? null : String(nextOffset);
+            return { data, next, last };
+        };
+        const response = await loader(params);
+        return new CursorPage({
+            params,
+            response,
+            loader,
+        });
+    }
+    /**
+     * Delete a thread and all associated events.
+     */
+    async delete(tid) {
+        await this.store.delete(tid);
+    }
+    /**
+     * Convenience wrapper around `events.list()` for fetching a thread's history.
+     *
+     * History is returned in descending sequence order by default (latest first).
+     */
+    async history(tid, params) {
+        const opts = {
+            after: params?.after,
+            limit: params?.limit,
+            order: params?.order ?? "desc",
+            kinds: params?.kinds,
+        };
+        const events = await this.store.history(tid, opts);
+        return events.filter(isPublicEvent).map((e) => e);
+    }
+    /**
+     * Update mutable thread fields.
+     *
+     * Currently only supports updating the human-readable `title`, which is
+     * stored in thread metadata as `metadata.title`.
+     */
+    async update(tid, patch) {
+        const current = await this.store.get(tid);
+        if (!current)
+            return null;
+        // Prevent context mutation while the thread is running.
+        if (patch.context !== undefined && current.state === RUNNING) {
+            throw new Error("Cannot update thread context while thread is running");
+        }
+        // build context patch
+        let contextPatch;
+        if ("context" in patch) {
+            const nextContextValue = patch.context === null
+                ? {}
+                : (patch.context ?? current.context.context);
+            contextPatch = new Context(current.namespace, nextContextValue);
+        }
+        // build metadata base according to caller intent
+        let metadata;
+        if ("metadata" in patch) {
+            if (patch.metadata === null) {
+                metadata = {};
+            }
+            else if (patch.metadata === undefined) {
+                metadata = current.metadata ? { ...current.metadata } : {};
+            }
+            else {
+                metadata = { ...patch.metadata };
+            }
+        }
+        else {
+            metadata = current.metadata ? { ...current.metadata } : {};
+        }
+        // apply title overlay on top of metadata
+        if ("title" in patch) {
+            const value = patch.title;
+            const trimmed = typeof value === "string" ? value.trim() : (value ?? undefined);
+            if (!trimmed) {
+                delete metadata.title; // clear title
+            }
+            else {
+                metadata.title = trimmed;
+            }
+        }
+        const nextMetadata = Object.keys(metadata).length > 0 ? metadata : null;
+        const updated = await this.store.update(tid, {
+            ...(contextPatch ? { context: contextPatch } : {}),
+            metadata: nextMetadata,
+        });
+        return MThreadCodec.encode(updated);
+    }
+}

package/dist/api/resources/threads/types.d.ts

@@ -0,0 +1,123 @@
+import type { ThreadState } from "../../../types/thread";
+import type { SortOrder } from "../../../storage";
+import type { CursorPageParams } from "../../../api/pagination/cursor";
+export interface RThreadHistoryParams {
+    /**
+     * Only return events with seq greater than this value.
+     */
+    after?: number;
+    /**
+     * Maximum number of events to return.
+     */
+    limit?: number;
+    /**
+     * Sort order by sequence number.
+     *
+     * Defaults to `"desc"` so callers see the latest events first.
+     */
+    order?: "asc" | "desc";
+    /**
+     * Restrict history to specific event kinds, e.g. `["message", "tool-result"]`.
+     */
+    kinds?: string[];
+}
+export interface RThreadsListParams extends CursorPageParams {
+    namespace?: string;
+    agentId?: string;
+    state?: ThreadState | ThreadState[];
+    parentTaskId?: string;
+    /**
+     * Only include threads created after this timestamp.
+     */
+    after?: Date;
+    /**
+     * Only include threads created before this timestamp.
+     */
+    before?: Date;
+    order?: {
+        createdAt?: SortOrder;
+        updatedAt?: SortOrder;
+    };
+}
+export interface RThreadGetOptions {
+    /**
+     * Include the thread's event history on the returned model.
+     *
+     * - `true` will fetch history with default options (latest-first).
+     * - An object lets you override history options (limit, kinds, order, etc.).
+     *
+     * This is equivalent to calling `kernl.threads.history(tid, opts)` and
+     * attaching the result to `thread.history`.
+     */
+    history?: true | RThreadHistoryParams;
+}
+/**
+ * Parameters for creating a new thread via the public Threads resource.
+ *
+ * Note: low-level API requires explicit agent + model. For most callers,
+ * prefer the agent-scoped helpers (agent.threads.create) which infer these.
+ */
+export interface RThreadCreateParams {
+    /**
+     * Owning agent id for the new thread.
+     */
+    agentId: string;
+    /**
+     * Optional explicit thread id.
+     *
+     * If omitted, a new id will be generated.
+     */
+    tid?: string;
+    /**
+     * Logical namespace to create the thread in.
+     *
+     * Defaults to `"kernl"` when not provided.
+     */
+    namespace?: string;
+    /**
+     * Optional human-readable title for the thread.
+     */
+    title?: string;
+    /**
+     * Initial context object for the thread.
+     */
+    context?: Record<string, unknown>;
+    /**
+     * Optional parent task id that spawned this thread, if any.
+     */
+    parentTaskId?: string | null;
+    /**
+     * Language model backing this thread.
+     */
+    model: {
+        provider: string;
+        modelId: string;
+    };
+    /**
+     * Arbitrary JSON-serializable metadata to attach to the thread.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Patch for updating caller-owned thread fields.
+ *
+ * Semantics for all fields:
+ * - `undefined` → leave the field unchanged
+ * - value (`object` / `string` / etc.) → replace the field
+ * - `null` → clear the field (for `title`, clears `metadata.title`)
+ */
+export interface RThreadUpdateParams {
+    /**
+     * Thread context object.
+     */
+    context?: Record<string, unknown> | null;
+    /**
+     * Arbitrary metadata bag attached to the thread.
+     */
+    metadata?: Record<string, unknown> | null;
+    /**
+     * Human-readable title (stored in `metadata.title`).
+     */
+    title?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/api/resources/threads/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/api/resources/threads/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAEvB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,KAAK,CAAC,EAAE,IAAI,CAAC;IAEb;;OAEG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC;IAEd,KAAK,CAAC,EAAE;QACN,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,SAAS,CAAC,EAAE,SAAS,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,IAAI,GAAG,oBAAoB,CAAC;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B;;OAEG;IACH,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAEzC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAE1C;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB"}

package/dist/api/resources/threads/utils.d.ts

@@ -0,0 +1,18 @@
+import { type Codec } from "@kernl-sdk/shared/lib";
+import type { Thread } from "../../../thread";
+import type { ThreadFilter, ThreadListOptions } from "../../../storage";
+import type { MThread } from "../../../api/models";
+import type { RThreadsListParams } from "./types";
+/**
+ * Converts an internal `Thread` runtime instance into an `MThread` model.
+ */
+export declare const MThreadCodec: Codec<Thread, MThread>;
+/**
+ * Converts `RThreadsListParams` into a `ThreadFilter` for the store.
+ */
+export declare const ThreadsFilterCodec: Codec<RThreadsListParams, ThreadFilter | undefined>;
+/**
+ * Converts list `order` params into `ThreadListOptions["order"]` for the store.
+ */
+export declare const ThreadsOrderCodec: Codec<RThreadsListParams["order"], ThreadListOptions["order"] | undefined>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/resources/threads/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/api/resources/threads/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAyB/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CACpC,kBAAkB,EAClB,YAAY,GAAG,SAAS,CA8BzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CACnC,kBAAkB,CAAC,OAAO,CAAC,EAC3B,iBAAiB,CAAC,OAAO,CAAC,GAAG,SAAS,CAwBvC,CAAC"}

package/dist/api/resources/threads/utils.js

@@ -0,0 +1,78 @@
+import { UnimplementedError } from "@kernl-sdk/shared/lib";
+/**
+ * Converts an internal `Thread` runtime instance into an `MThread` model.
+ */
+export const MThreadCodec = {
+    encode(thread) {
+        const rawTitle = thread.metadata?.title;
+        const title = typeof rawTitle === "string" ? rawTitle : null;
+        return {
+            tid: thread.tid,
+            namespace: thread.namespace,
+            agentId: thread.agent.id,
+            title,
+            model: {
+                provider: thread.model.provider,
+                modelId: thread.model.modelId,
+            },
+            context: thread.context.context,
+            parentTaskId: thread.parent?.id ?? null,
+            state: thread.state,
+            createdAt: thread.createdAt,
+            updatedAt: thread.updatedAt,
+        };
+    },
+    decode(_model) {
+        throw new UnimplementedError();
+    },
+};
+/**
+ * Converts `RThreadsListParams` into a `ThreadFilter` for the store.
+ */
+export const ThreadsFilterCodec = {
+    encode(params) {
+        const filter = {};
+        if (params.namespace !== undefined) {
+            filter.namespace = params.namespace;
+        }
+        if (params.state !== undefined) {
+            filter.state = params.state;
+        }
+        if (params.agentId !== undefined) {
+            filter.agentId = params.agentId;
+        }
+        if (params.parentTaskId !== undefined) {
+            filter.parentTaskId = params.parentTaskId;
+        }
+        if (params.after !== undefined) {
+            filter.createdAfter = params.after;
+        }
+        if (params.before !== undefined) {
+            filter.createdBefore = params.before;
+        }
+        return Object.keys(filter).length > 0 ? filter : undefined;
+    },
+    decode(_filter) {
+        throw new UnimplementedError();
+    },
+};
+/**
+ * Converts list `order` params into `ThreadListOptions["order"]` for the store.
+ */
+export const ThreadsOrderCodec = {
+    encode(order) {
+        if (!order)
+            return undefined;
+        const result = {};
+        if (order.createdAt !== undefined) {
+            result.createdAt = order.createdAt;
+        }
+        if (order.updatedAt !== undefined) {
+            result.updatedAt = order.updatedAt;
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    },
+    decode(_order) {
+        throw new UnimplementedError();
+    },
+};

package/dist/context.d.ts

@@ -7,6 +7,10 @@ export type ApprovalStatus = "approved" | "rejected" | "pending";
  * execution units.
  */
 export declare class Context<TContext = UnknownContext> {
+    /**
+     * The namespace that this context belongs to.
+     */
+    namespace: string;
     /**
      * The inner context object.
      */
@@ -26,7 +30,7 @@ export declare class Context<TContext = UnknownContext> {
      * (TEMPORARY) Used until the actions system is refined.
      */
     reject(callId: string): void;
-    constructor(context?: TContext);
+    constructor(namespace?: string, context?: TContext);
     /**
      * Renders the context as a prompt using the default format selected. Kernel would inject this info automatically, but exposed in case of control
      */