@kernl-sdk/storage 0.1.9

package/dist/serde/thread.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Thread serialization - codecs for converting between domain types and database records.
+ */
+import { type Codec } from "@kernl-sdk/shared/lib";
+import type { IThread, ThreadEvent } from "kernl/internal";
+import type { NewThread } from "../thread/types";
+/**
+ * Decoded thread record - validated but not hydrated.
+ *
+ * Has all IThread fields except:
+ * - agent/model are replaced with agentId/model (string references)
+ * - input/history/task are not included (loaded separately, task becomes parentTaskId)
+ * - context is raw JSONB data (needs reconstruction into Context instance)
+ */
+export type DecodedThread = Omit<IThread, "agent" | "model" | "input" | "history" | "task" | "context"> & {
+    namespace: string;
+    agentId: string;
+    model: string;
+    parentTaskId: string | null;
+    context: unknown;
+};
+export declare const ThreadCodec: Codec<DecodedThread, {
+    id: string;
+    namespace: string;
+    agent_id: string;
+    model: string;
+    context: unknown;
+    parent_task_id: string | null;
+    tick: number;
+    state: "running" | "stopped" | "interruptible" | "uninterruptible" | "zombie" | "dead";
+    created_at: number;
+    updated_at: number;
+    metadata: Record<string, unknown> | null;
+}>;
+export declare const ThreadEventRecordCodec: Codec<ThreadEvent, {
+    id: string;
+    tid: string;
+    seq: number;
+    timestamp: number;
+    metadata: Record<string, unknown> | null;
+    kind: "message";
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    tid: string;
+    seq: number;
+    timestamp: number;
+    metadata: Record<string, unknown> | null;
+    kind: "reasoning";
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    tid: string;
+    seq: number;
+    timestamp: number;
+    metadata: Record<string, unknown> | null;
+    kind: "tool-call";
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    tid: string;
+    seq: number;
+    timestamp: number;
+    metadata: Record<string, unknown> | null;
+    kind: "tool-result";
+    data: Record<string, unknown>;
+} | {
+    id: string;
+    tid: string;
+    seq: number;
+    timestamp: number;
+    metadata: Record<string, unknown> | null;
+    kind: "system";
+    data: null;
+}>;
+export declare const NewThreadCodec: Codec<NewThread, {
+    id: string;
+    namespace: string;
+    agent_id: string;
+    model: string;
+    context: unknown;
+    parent_task_id: string | null;
+    tick: number;
+    state: "running" | "stopped" | "interruptible" | "uninterruptible" | "zombie" | "dead";
+    created_at: number;
+    updated_at: number;
+    metadata: Record<string, unknown> | null;
+}>;
+//# sourceMappingURL=thread.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/serde/thread.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAmB,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAK3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAC9B,OAAO,EACP,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAC7D,GAAG;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAyCF,eAAO,MAAM,WAAW;;;;;;;;;;;;EAGtB,CAAC;AAwDH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AA0CH,eAAO,MAAM,cAAc;;;;;;;;;;;;EAGzB,CAAC"}

package/dist/serde/thread.js

@@ -0,0 +1,139 @@
+/**
+ * Thread serialization - codecs for converting between domain types and database records.
+ */
+import { neapolitanCodec } from "@kernl-sdk/shared/lib";
+import { STOPPED } from "@kernl-sdk/protocol";
+import { ThreadRecordSchema, ThreadEventRecordSchema } from "../thread/schema";
+/* ---- Codecs ---- */
+/**
+ * Thread codec - converts between DecodedThread and ThreadRecord.
+ */
+const rawThreadCodec = {
+    encode(decoded) {
+        return {
+            id: decoded.tid,
+            namespace: decoded.namespace,
+            agent_id: decoded.agentId,
+            model: decoded.model,
+            parent_task_id: decoded.parentTaskId,
+            context: decoded.context,
+            tick: decoded.tick,
+            state: decoded.state,
+            created_at: decoded.createdAt.getTime(),
+            updated_at: decoded.updatedAt.getTime(),
+            metadata: decoded.metadata,
+        };
+    },
+    decode(record) {
+        return {
+            tid: record.id,
+            namespace: record.namespace,
+            agentId: record.agent_id,
+            model: record.model,
+            parentTaskId: record.parent_task_id,
+            context: record.context,
+            tick: record.tick,
+            state: record.state,
+            createdAt: new Date(record.created_at),
+            updatedAt: new Date(record.updated_at),
+            metadata: record.metadata,
+        };
+    },
+};
+export const ThreadCodec = neapolitanCodec({
+    codec: rawThreadCodec,
+    schema: ThreadRecordSchema,
+});
+/**
+ * ThreadEvent codec - converts between flat ThreadEvent and ThreadEventRecord.
+ *
+ * App layer: {kind, ...dataFields, id, tid, seq, timestamp, metadata}
+ * DB layer:  {kind, data: {...dataFields}, id, tid, seq, timestamp, metadata}
+ */
+const rawThreadEventCodec = {
+    encode(event) {
+        const base = {
+            id: event.id,
+            tid: event.tid,
+            seq: event.seq,
+            timestamp: event.timestamp.getTime(),
+            metadata: event.metadata ?? null,
+        };
+        // System events have no data
+        if (event.kind === "system") {
+            return { ...base, kind: "system", data: null };
+        }
+        // Extract data (everything except base fields and kind)
+        const { id, tid, seq, timestamp, metadata, kind, ...data } = event;
+        return {
+            ...base,
+            kind: event.kind,
+            data,
+        };
+    },
+    decode(record) {
+        const base = {
+            id: record.id,
+            tid: record.tid,
+            seq: record.seq,
+            timestamp: new Date(record.timestamp),
+            metadata: record.metadata ?? {},
+        };
+        // System events have no data
+        if (record.kind === "system") {
+            return { ...base, kind: "system" };
+        }
+        // For non-system events, data is always a record (enforced by schema)
+        return {
+            ...base,
+            kind: record.kind,
+            ...record.data,
+        };
+    },
+};
+export const ThreadEventRecordCodec = neapolitanCodec({
+    codec: rawThreadEventCodec,
+    schema: ThreadEventRecordSchema,
+});
+/**
+ * NewThread codec - converts NewThread input to ThreadRecord for insertion.
+ *
+ * Handles default values at encoding time (tick=0, state="stopped", timestamps=now).
+ */
+const rawNewThreadCodec = {
+    encode(thread) {
+        const now = Date.now();
+        return {
+            id: thread.id,
+            namespace: thread.namespace,
+            agent_id: thread.agentId,
+            model: thread.model,
+            context: thread.context ?? {},
+            tick: thread.tick ?? 0,
+            state: thread.state ?? STOPPED,
+            parent_task_id: thread.parentTaskId ?? null,
+            metadata: thread.metadata ?? null,
+            created_at: thread.createdAt?.getTime() ?? now,
+            updated_at: thread.updatedAt?.getTime() ?? now,
+        };
+    },
+    decode(record) {
+        return {
+            id: record.id,
+            namespace: record.namespace,
+            agentId: record.agent_id,
+            model: record.model,
+            context: record.context,
+            tick: record.tick,
+            state: record.state,
+            parentTaskId: record.parent_task_id,
+            metadata: record.metadata,
+            createdAt: new Date(record.created_at),
+            updatedAt: new Date(record.updated_at),
+        };
+    },
+};
+export const NewThreadCodec = neapolitanCodec({
+    codec: rawNewThreadCodec,
+    schema: ThreadRecordSchema,
+});

package/dist/table.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Schema name for all kernl tables.
+ */
+export declare const SCHEMA_NAME = "kernl";
+/**
+ * Table definition with name, columns, and optional constraints.
+ */
+export interface Table<Name extends string, Cols extends Record<string, Column>> {
+    name: Name;
+    columns: Cols;
+    constraints?: TableConstraint[];
+}
+/**
+ * Define a table with name, columns, and optional constraints.
+ */
+export declare function defineTable<const Name extends string, const Cols extends Record<string, Column>>(name: Name, columns: Cols, constraints?: TableConstraint[]): Table<Name, Cols>;
+export type ColumnType = "text" | "integer" | "bigint" | "jsonb";
+export type OnDeleteAction = "CASCADE" | "SET NULL" | "RESTRICT";
+/**
+ * Column definition with type and constraints.
+ */
+export interface Column<T = unknown> {
+    type: ColumnType;
+    _table?: string;
+    _column?: string;
+    _pk?: boolean;
+    _nullable?: boolean;
+    _unique?: boolean;
+    _default?: T;
+    _fk?: {
+        table: string;
+        column: string;
+    };
+    _onDelete?: OnDeleteAction;
+    primaryKey(): Column<T>;
+    nullable(): Column<T>;
+    default(val: T): Column<T>;
+    unique(): Column<T>;
+    references(ref: () => Column, opts?: {
+        onDelete?: OnDeleteAction;
+    }): Column<T>;
+    encode(val: T): string;
+    decode(val: string): T;
+}
+export declare const text: () => Column<string>;
+export declare const integer: () => Column<number>;
+export declare const bigint: () => Column<number>;
+export declare const jsonb: <T = unknown>() => Column<T>;
+export declare const timestamps: {
+    created_at: Column<number>;
+    updated_at: Column<number>;
+};
+/**
+ * Table-level constraint types.
+ */
+export type TableConstraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint | CheckConstraint | IndexConstraint;
+export interface UniqueConstraint {
+    readonly kind: "unique";
+    columns: string[];
+    name?: string;
+}
+export interface IndexConstraint {
+    readonly kind: "index";
+    columns: string[];
+    unique?: boolean;
+}
+export interface PrimaryKeyConstraint {
+    readonly kind: "pkey";
+    columns: string[];
+    name?: string;
+}
+export interface ForeignKeyConstraint {
+    readonly kind: "fkey";
+    columns: string[];
+    references: {
+        table: string;
+        columns: string[];
+    };
+    onDelete?: OnDeleteAction;
+    name?: string;
+}
+export interface CheckConstraint {
+    readonly kind: "check";
+    expression: string;
+    name?: string;
+}
+//# sourceMappingURL=table.d.ts.map

package/dist/table.d.ts.map

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

package/dist/table.js

@@ -0,0 +1,80 @@
+/**
+ * Schema name for all kernl tables.
+ */
+export const SCHEMA_NAME = "kernl";
+/**
+ * Define a table with name, columns, and optional constraints.
+ */
+export function defineTable(name, columns, constraints) {
+    // set table/column metadata on each column for FK resolution
+    for (const cname in columns) {
+        columns[cname]._table = name;
+        columns[cname]._column = cname;
+    }
+    return { name, columns, constraints };
+}
+export const text = () => col("text");
+export const integer = () => col("integer");
+export const bigint = () => col("bigint");
+export const jsonb = () => col("jsonb");
+export const timestamps = {
+    created_at: bigint(),
+    updated_at: bigint(),
+};
+function col(type) {
+    const c = {
+        type,
+        primaryKey() {
+            this._pk = true;
+            return this;
+        },
+        nullable() {
+            this._nullable = true;
+            return this;
+        },
+        default(val) {
+            this._default = val;
+            return this;
+        },
+        unique() {
+            this._unique = true;
+            return this;
+        },
+        references(ref, opts) {
+            const targetCol = ref();
+            if (targetCol._table && targetCol._column) {
+                this._fk = {
+                    table: targetCol._table,
+                    column: targetCol._column,
+                };
+            }
+            this._onDelete = opts?.onDelete;
+            return this;
+        },
+        encode(val) {
+            if (val === null || val === undefined)
+                return "NULL";
+            switch (this.type) {
+                case "text":
+                    return `'${String(val).replace(/'/g, "''")}'`;
+                case "integer":
+                case "bigint":
+                    return String(val);
+                case "jsonb":
+                    return `'${JSON.stringify(val)}'`;
+            }
+        },
+        decode(val) {
+            switch (this.type) {
+                case "text":
+                    return val;
+                case "integer":
+                case "bigint":
+                    return Number.parseInt(val, 10);
+                case "jsonb":
+                    return JSON.parse(val);
+            }
+        },
+    };
+    return c;
+}

package/dist/thread/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thread storage types and utilities.
+ */
+export * from "./types";
+export * from "./store";
+export * from "./schema";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/thread/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/thread/index.js

@@ -0,0 +1,6 @@
+/**
+ * Thread storage types and utilities.
+ */
+export * from "./types";
+export * from "./store";
+export * from "./schema";

package/dist/thread/schema.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Thread record schemas and table definitions.
+ */
+import { z } from "zod";
+/**
+ * Threads table schema.
+ */
+export declare const TABLE_THREADS: import("../table").Table<"threads", {
+    readonly created_at: import("../table").Column<number>;
+    readonly updated_at: import("../table").Column<number>;
+    readonly id: import("../table").Column<string>;
+    readonly namespace: import("../table").Column<string>;
+    readonly agent_id: import("../table").Column<string>;
+    readonly model: import("../table").Column<string>;
+    readonly context: import("../table").Column<unknown>;
+    readonly parent_task_id: import("../table").Column<string>;
+    readonly tick: import("../table").Column<number>;
+    readonly state: import("../table").Column<string>;
+    readonly metadata: import("../table").Column<unknown>;
+}>;
+/**
+ * Thread events table schema.
+ */
+export declare const TABLE_THREAD_EVENTS: import("../table").Table<"thread_events", {
+    readonly id: import("../table").Column<string>;
+    readonly tid: import("../table").Column<string>;
+    readonly seq: import("../table").Column<number>;
+    readonly kind: import("../table").Column<string>;
+    readonly timestamp: import("../table").Column<number>;
+    readonly data: import("../table").Column<unknown>;
+    readonly metadata: import("../table").Column<unknown>;
+}>;
+/**
+ * Migrations table.
+ */
+export declare const TABLE_MIGRATIONS: import("../table").Table<"migrations", {
+    readonly id: import("../table").Column<string>;
+    readonly applied_at: import("../table").Column<number>;
+}>;
+/**
+ * Thread record schema (zod-first).
+ */
+export declare const ThreadRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    agent_id: z.ZodString;
+    model: z.ZodString;
+    context: z.ZodUnknown;
+    parent_task_id: z.ZodNullable<z.ZodString>;
+    tick: z.ZodNumber;
+    state: z.ZodEnum<{
+        running: "running";
+        stopped: "stopped";
+        interruptible: "interruptible";
+        uninterruptible: "uninterruptible";
+        zombie: "zombie";
+        dead: "dead";
+    }>;
+    created_at: z.ZodNumber;
+    updated_at: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ThreadRecord = z.infer<typeof ThreadRecordSchema>;
+/**
+ * Thread event inner data - stored in JSONB column.
+ *
+ * Always an object (record) for non-system events. Inner data is validated by protocol layer
+ * and is already JSON-serializable. The actual structure depends on the event kind:
+ * - message: {role, content, ...}
+ * - tool-call: {callId, toolId, state, arguments}
+ * - tool-result: {callId, toolId, state, result, error}
+ * - reasoning: {text}
+ * - system: null (handled separately)
+ */
+export declare const ThreadEventInnerSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type ThreadEventInner = z.infer<typeof ThreadEventInnerSchema>;
+/**
+ * Thread event record schema (discriminated union by kind).
+ */
+export declare const ThreadEventRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    tid: z.ZodString;
+    seq: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"message">;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    tid: z.ZodString;
+    seq: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"reasoning">;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    tid: z.ZodString;
+    seq: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"tool-call">;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    tid: z.ZodString;
+    seq: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"tool-result">;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    tid: z.ZodString;
+    seq: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"system">;
+    data: z.ZodNull;
+}, z.core.$strip>], "kind">;
+export type ThreadEventRecord = z.infer<typeof ThreadEventRecordSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/thread/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAsBzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;EAqB/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;EAG3B,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;iBAY7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,wCAAoC,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAqDtE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAMlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}