@dawn-ai/sqlite-storage 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Brian Love
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/checkpointer/index.d.ts

@@ -0,0 +1,7 @@
+import { DawnSqliteSaver } from "./saver.js";
+export interface SqliteCheckpointerOptions {
+    readonly path: string;
+}
+export declare function sqliteCheckpointer(options: SqliteCheckpointerOptions): DawnSqliteSaver;
+export { DawnSqliteSaver } from "./saver.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpointer/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAG5C,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,eAAe,CAItF;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA"}

package/dist/checkpointer/index.js

@@ -0,0 +1,10 @@
+import { openDb } from "../internal/db.js";
+import { runMigrations } from "../internal/migrate.js";
+import { DawnSqliteSaver } from "./saver.js";
+import { CHECKPOINTER_MIGRATIONS } from "./schema.js";
+export function sqliteCheckpointer(options) {
+    const db = openDb(options.path);
+    runMigrations(db, CHECKPOINTER_MIGRATIONS);
+    return new DawnSqliteSaver(db);
+}
+export { DawnSqliteSaver } from "./saver.js";

package/dist/checkpointer/saver.d.ts

@@ -0,0 +1,14 @@
+import type { RunnableConfig } from "@langchain/core/runnables";
+import type { Checkpoint, CheckpointListOptions, CheckpointMetadata, CheckpointTuple } from "@langchain/langgraph-checkpoint";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import type { Db } from "../internal/db.js";
+export declare class DawnSqliteSaver extends BaseCheckpointSaver {
+    private readonly db;
+    constructor(db: Db);
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, _newVersions: Record<string, string | number>): Promise<RunnableConfig>;
+    putWrites(config: RunnableConfig, writes: [string, unknown][], taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+}
+//# sourceMappingURL=saver.d.ts.map

package/dist/checkpointer/saver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saver.d.ts","sourceRoot":"","sources":["../../src/checkpointer/saver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,KAAK,EACV,UAAU,EACV,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EAChB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAA;AACrE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAA;AAuE3C,qBAAa,eAAgB,SAAQ,mBAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAI7B,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAoCrE,IAAI,CACT,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAAC,eAAe,CAAC;IA4B5B,GAAG,CACP,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,kBAAkB,EAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAC5C,OAAO,CAAC,cAAc,CAAC;IA2BpB,SAAS,CACb,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAqCV,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAYpD"}

package/dist/checkpointer/saver.js

@@ -0,0 +1,155 @@
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+async function buildTuple(row, writes, serde) {
+    const checkpoint = (await serde.loadsTyped(row.type ?? "json", row.checkpoint));
+    const metadata = (await serde.loadsTyped("json", row.metadata));
+    const pendingWrites = await Promise.all(writes.map(async (w) => [
+        w.task_id,
+        w.channel,
+        w.value != null ? await serde.loadsTyped(w.type ?? "json", w.value) : null,
+    ]));
+    const config = {
+        configurable: {
+            thread_id: row.thread_id,
+            checkpoint_ns: row.checkpoint_ns,
+            checkpoint_id: row.checkpoint_id,
+        },
+    };
+    const base = { config, checkpoint, metadata, pendingWrites };
+    if (row.parent_checkpoint_id != null) {
+        return {
+            ...base,
+            parentConfig: {
+                configurable: {
+                    thread_id: row.thread_id,
+                    checkpoint_ns: row.checkpoint_ns,
+                    checkpoint_id: row.parent_checkpoint_id,
+                },
+            },
+        };
+    }
+    return base;
+}
+export class DawnSqliteSaver extends BaseCheckpointSaver {
+    db;
+    constructor(db) {
+        super();
+        this.db = db;
+    }
+    async getTuple(config) {
+        const threadId = config.configurable?.thread_id;
+        if (!threadId)
+            return undefined;
+        const ns = config.configurable?.checkpoint_ns ?? "";
+        const ckptId = config.configurable?.checkpoint_id;
+        let row;
+        if (ckptId) {
+            row = this.db
+                .prepare("SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata FROM checkpoints WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?")
+                .get(threadId, ns, ckptId);
+        }
+        else {
+            row = this.db
+                .prepare("SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata FROM checkpoints WHERE thread_id = ? AND checkpoint_ns = ? ORDER BY checkpoint_id DESC LIMIT 1")
+                .get(threadId, ns);
+        }
+        if (!row)
+            return undefined;
+        const typedRow = row;
+        const writeRows = this.db
+            .prepare("SELECT task_id, channel, type, value FROM writes WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ? ORDER BY task_id, idx")
+            .all(typedRow.thread_id, typedRow.checkpoint_ns, typedRow.checkpoint_id);
+        return buildTuple(typedRow, writeRows, this.serde);
+    }
+    async *list(config, options) {
+        const threadId = config.configurable?.thread_id;
+        if (!threadId)
+            return;
+        const ns = config.configurable?.checkpoint_ns ?? "";
+        const before = options?.before?.configurable?.checkpoint_id;
+        const limit = options?.limit ?? -1;
+        const params = [threadId, ns];
+        let sql = "SELECT thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata FROM checkpoints WHERE thread_id = ? AND checkpoint_ns = ?";
+        if (before) {
+            sql += " AND checkpoint_id < ?";
+            params.push(before);
+        }
+        sql += " ORDER BY checkpoint_id DESC";
+        if (limit > 0) {
+            sql += " LIMIT ?";
+            params.push(limit);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        for (const row of rows) {
+            // Note: list returns lightweight tuples without pendingWrites. Callers that
+            // need writes should call getTuple(specificCheckpointId) for full hydration.
+            // This matches the @langchain/langgraph-checkpoint-sqlite reference behavior.
+            yield await buildTuple(row, [], this.serde);
+        }
+    }
+    async put(config, checkpoint, metadata, _newVersions) {
+        const threadId = config.configurable?.thread_id;
+        if (!threadId) {
+            throw new Error("[DawnSqliteSaver] config.configurable.thread_id is required");
+        }
+        const ns = config.configurable?.checkpoint_ns ?? "";
+        const parentId = config.configurable?.checkpoint_id ?? null;
+        // _newVersions is provided by LangGraph for version-tracking purposes but is
+        // not persisted separately — versions live inside the serialized checkpoint payload.
+        // Use the inherited serde (JsonPlusSerializer) so that LangChain objects such
+        // as BaseMessage instances survive the round-trip through SQLite.
+        const [checkpointType, checkpointBytes] = await this.serde.dumpsTyped(checkpoint);
+        const [, metadataBytes] = await this.serde.dumpsTyped(metadata);
+        this.db
+            .prepare(`INSERT OR REPLACE INTO checkpoints
+         (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(threadId, ns, checkpoint.id, parentId, checkpointType, checkpointBytes, metadataBytes);
+        return {
+            configurable: { thread_id: threadId, checkpoint_ns: ns, checkpoint_id: checkpoint.id },
+        };
+    }
+    async putWrites(config, writes, taskId) {
+        const threadId = config.configurable?.thread_id;
+        if (!threadId) {
+            throw new Error("[DawnSqliteSaver] config.configurable.thread_id is required");
+        }
+        const ns = config.configurable?.checkpoint_ns ?? "";
+        const ckptId = config.configurable?.checkpoint_id;
+        if (!ckptId) {
+            throw new Error("[DawnSqliteSaver] config.configurable.checkpoint_id is required");
+        }
+        // Serialize all values before opening the transaction (serde is async).
+        const serialized = await Promise.all(writes.map(async ([channel, value]) => {
+            const [type, bytes] = await this.serde.dumpsTyped(value);
+            return { channel, type, bytes };
+        }));
+        const stmt = this.db.prepare(`INSERT OR REPLACE INTO writes
+       (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.db.exec("BEGIN");
+        try {
+            serialized.forEach(({ channel, type, bytes }, idx) => {
+                stmt.run(threadId, ns, ckptId, taskId, idx, channel, type, bytes);
+            });
+            this.db.exec("COMMIT");
+        }
+        catch (err) {
+            this.db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+    async deleteThread(threadId) {
+        if (!threadId)
+            throw new Error("[DawnSqliteSaver] deleteThread requires a thread_id");
+        this.db.exec("BEGIN");
+        try {
+            this.db.prepare("DELETE FROM writes WHERE thread_id = ?").run(threadId);
+            this.db.prepare("DELETE FROM checkpoints WHERE thread_id = ?").run(threadId);
+            this.db.exec("COMMIT");
+        }
+        catch (err) {
+            this.db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+}

package/dist/checkpointer/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from "../internal/migrate.js";
+export declare const CHECKPOINTER_MIGRATIONS: readonly Migration[];
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/checkpointer/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD,eAAO,MAAM,uBAAuB,EAAE,SAAS,SAAS,EA4BvD,CAAA"}

package/dist/checkpointer/schema.js

@@ -0,0 +1,29 @@
+export const CHECKPOINTER_MIGRATIONS = [
+    {
+        version: 1,
+        up: `
+      CREATE TABLE checkpoints (
+        thread_id TEXT NOT NULL,
+        checkpoint_ns TEXT NOT NULL DEFAULT '',
+        checkpoint_id TEXT NOT NULL,
+        parent_checkpoint_id TEXT,
+        type TEXT,
+        checkpoint BLOB NOT NULL,
+        metadata BLOB NOT NULL,
+        PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+      );
+      CREATE INDEX idx_checkpoints_thread ON checkpoints(thread_id, checkpoint_ns);
+      CREATE TABLE writes (
+        thread_id TEXT NOT NULL,
+        checkpoint_ns TEXT NOT NULL DEFAULT '',
+        checkpoint_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        idx INTEGER NOT NULL,
+        channel TEXT NOT NULL,
+        type TEXT,
+        value BLOB,
+        PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+      );
+    `,
+    },
+];

package/dist/checkpointer/serde.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeBlob(value: unknown): Uint8Array;
+export declare function decodeBlob(buf: Uint8Array): unknown;
+//# sourceMappingURL=serde.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serde.d.ts","sourceRoot":"","sources":["../../src/checkpointer/serde.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAErD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAEnD"}

package/dist/checkpointer/serde.js

@@ -0,0 +1,8 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function encodeBlob(value) {
+    return encoder.encode(JSON.stringify(value));
+}
+export function decodeBlob(buf) {
+    return JSON.parse(decoder.decode(buf));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { SqliteCheckpointerOptions } from "./checkpointer/index.js";
+export { DawnSqliteSaver, sqliteCheckpointer } from "./checkpointer/index.js";
+export type { CreateThreadInput, Thread, ThreadStatus, ThreadsStore, ThreadsStoreOptions, } from "./threads/index.js";
+export { createThreadsStore } from "./threads/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC7E,YAAY,EACV,iBAAiB,EACjB,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,mBAAmB,GACpB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { DawnSqliteSaver, sqliteCheckpointer } from "./checkpointer/index.js";
+export { createThreadsStore } from "./threads/index.js";

package/dist/internal/db.d.ts

@@ -0,0 +1,4 @@
+import { DatabaseSync } from "node:sqlite";
+export type Db = DatabaseSync;
+export declare function openDb(path: string): Db;
+//# sourceMappingURL=db.d.ts.map

package/dist/internal/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/internal/db.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,EAAE,GAAG,YAAY,CAAA;AAE7B,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAYvC"}

package/dist/internal/db.js

@@ -0,0 +1,16 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export function openDb(path) {
+    const isMemory = path === ":memory:";
+    if (!isMemory) {
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    const db = new DatabaseSync(path);
+    if (!isMemory) {
+        db.exec("PRAGMA journal_mode = WAL");
+    }
+    db.exec("PRAGMA foreign_keys = ON");
+    db.exec("PRAGMA synchronous = NORMAL");
+    return db;
+}

package/dist/internal/migrate.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseSync } from "node:sqlite";
+export interface Migration {
+    readonly version: number;
+    readonly up: string;
+}
+export declare function runMigrations(db: DatabaseSync, migrations: readonly Migration[]): void;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/internal/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/internal/migrate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CAmBtF"}

package/dist/internal/migrate.js

@@ -0,0 +1,20 @@
+export function runMigrations(db, migrations) {
+    db.exec("CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)");
+    const row = db.prepare("SELECT max(version) AS v FROM schema_version").get();
+    const current = row?.v ?? 0;
+    const sorted = [...migrations].sort((a, b) => a.version - b.version);
+    for (const m of sorted) {
+        if (m.version <= current)
+            continue;
+        db.exec("BEGIN");
+        try {
+            db.exec(m.up);
+            db.prepare("INSERT INTO schema_version(version) VALUES (?)").run(m.version);
+            db.exec("COMMIT");
+        }
+        catch (err) {
+            db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+}

package/dist/threads/index.d.ts

@@ -0,0 +1,6 @@
+export interface ThreadsStoreOptions {
+    readonly path: string;
+}
+export declare function createThreadsStore(options: ThreadsStoreOptions): import("./store.js").ThreadsStore;
+export type { CreateThreadInput, Thread, ThreadStatus, ThreadsStore } from "./store.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/threads/index.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,qCAI9D;AAED,YAAY,EAAE,iBAAiB,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA"}

package/dist/threads/index.js

@@ -0,0 +1,9 @@
+import { openDb } from "../internal/db.js";
+import { runMigrations } from "../internal/migrate.js";
+import { THREADS_MIGRATIONS } from "./schema.js";
+import { makeThreadsStore } from "./store.js";
+export function createThreadsStore(options) {
+    const db = openDb(options.path);
+    runMigrations(db, THREADS_MIGRATIONS);
+    return makeThreadsStore(db);
+}

package/dist/threads/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from "../internal/migrate.js";
+export declare const THREADS_MIGRATIONS: readonly Migration[];
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/threads/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD,eAAO,MAAM,kBAAkB,EAAE,SAAS,SAAS,EAclD,CAAA"}

package/dist/threads/schema.js

@@ -0,0 +1,15 @@
+export const THREADS_MIGRATIONS = [
+    {
+        version: 1,
+        up: `
+      CREATE TABLE threads (
+        thread_id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'idle'
+      );
+      CREATE INDEX idx_threads_updated ON threads(updated_at DESC);
+    `,
+    },
+];

package/dist/threads/store.d.ts

@@ -0,0 +1,28 @@
+import type { Db } from "../internal/db.js";
+export type ThreadStatus = "idle" | "busy" | "interrupted";
+export interface Thread {
+    readonly thread_id: string;
+    readonly created_at: string;
+    readonly updated_at: string;
+    readonly metadata: Record<string, unknown>;
+    readonly status: ThreadStatus;
+}
+export interface CreateThreadInput {
+    readonly thread_id?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface ThreadsStore {
+    createThread(input: CreateThreadInput): Promise<Thread>;
+    getThread(threadId: string): Promise<Thread | undefined>;
+    deleteThread(threadId: string): Promise<void>;
+    listThreads(): Promise<Thread[]>;
+    updateStatus(threadId: string, status: ThreadStatus): Promise<void>;
+    /**
+     * Shallow-merge `patch` into the thread's existing metadata. No-op if the
+     * thread does not exist. Used to persist durable per-thread runtime facts
+     * (e.g. the last route key) so they survive a server restart.
+     */
+    updateMetadata(threadId: string, patch: Record<string, unknown>): Promise<void>;
+}
+export declare function makeThreadsStore(db: Db): ThreadsStore;
+//# sourceMappingURL=store.d.ts.map

package/dist/threads/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/threads/store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAA;AAE3C,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAA;AAE1D,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC1C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC5C;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACvD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IACxD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7C,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IAChC,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnE;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAChF;AAwBD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY,CA2DrD"}

package/dist/threads/store.js

@@ -0,0 +1,60 @@
+import { randomBytes } from "node:crypto";
+function rowToThread(row) {
+    return {
+        thread_id: row.thread_id,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        metadata: JSON.parse(row.metadata),
+        status: row.status,
+    };
+}
+function newThreadId() {
+    return `t-${randomBytes(4).toString("hex")}`;
+}
+export function makeThreadsStore(db) {
+    return {
+        async createThread(input) {
+            const now = new Date().toISOString();
+            const threadId = input.thread_id ?? newThreadId();
+            const metadata = JSON.stringify(input.metadata ?? {});
+            db.prepare("INSERT INTO threads(thread_id, created_at, updated_at, metadata, status) VALUES (?, ?, ?, ?, 'idle')").run(threadId, now, now, metadata);
+            return {
+                thread_id: threadId,
+                created_at: now,
+                updated_at: now,
+                metadata: input.metadata ?? {},
+                status: "idle",
+            };
+        },
+        async getThread(threadId) {
+            const row = db
+                .prepare("SELECT thread_id, created_at, updated_at, metadata, status FROM threads WHERE thread_id = ?")
+                .get(threadId);
+            return row ? rowToThread(row) : undefined;
+        },
+        async deleteThread(threadId) {
+            db.prepare("DELETE FROM threads WHERE thread_id = ?").run(threadId);
+        },
+        async listThreads() {
+            const rows = db
+                .prepare("SELECT thread_id, created_at, updated_at, metadata, status FROM threads ORDER BY updated_at DESC")
+                .all();
+            return rows.map(rowToThread);
+        },
+        async updateStatus(threadId, status) {
+            const now = new Date().toISOString();
+            db.prepare("UPDATE threads SET status = ?, updated_at = ? WHERE thread_id = ?").run(status, now, threadId);
+        },
+        async updateMetadata(threadId, patch) {
+            const row = db
+                .prepare("SELECT metadata FROM threads WHERE thread_id = ?")
+                .get(threadId);
+            if (!row)
+                return;
+            const current = JSON.parse(row.metadata);
+            const merged = JSON.stringify({ ...current, ...patch });
+            const now = new Date().toISOString();
+            db.prepare("UPDATE threads SET metadata = ?, updated_at = ? WHERE thread_id = ?").run(merged, now, threadId);
+        },
+    };
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@dawn-ai/sqlite-storage",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/cacheplane/dawnai/tree/main/packages/sqlite-storage#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cacheplane/dawnai.git",
+    "directory": "packages/sqlite-storage"
+  },
+  "bugs": {
+    "url": "https://github.com/cacheplane/dawnai/issues"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@langchain/core": "^1.1.44",
+    "@langchain/langgraph-checkpoint": "^1.0.2"
+  },
+  "devDependencies": {
+    "@langchain/core": "^1.1.47",
+    "@langchain/langgraph-checkpoint": "^1.0.2",
+    "@types/node": "25.6.0",
+    "@dawn-ai/config-typescript": "0.2.0"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "lint": "biome check --config-path ../config-biome/biome.json package.json src tsconfig.json vitest.config.ts",
+    "test": "vitest --run --config vitest.config.ts --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  }
+}