@ixo/sqlite-saver 1.0.4

package/.eslintrc.js

@@ -0,0 +1,9 @@
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: ['@ixo/eslint-config/nest.js'],
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+};

package/.prettierignore

@@ -0,0 +1,3 @@
+pnpm-lock.yaml
+
+node_modules

package/.prettierrc.js

@@ -0,0 +1,4 @@
+/** @type {import("prettier").Config} */
+module.exports = {
+  ...require('@ixo/eslint-config/prettier-base'),
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @ixo/sqlite-saver@1.0.4 build /home/runner/actions-runner/_work/ixo-oracles-boilerplate/ixo-oracles-boilerplate/packages/sqlite-saver
+> tsc
+

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# @ixo/sqlite-saver
+
+## 1.0.4
+
+### Patch Changes
+
+- [`c643779`](https://github.com/ixoworld/companion/commit/c6437794acd28c833074763449502daf61e40a4c) Thanks [@youssefhany-ixo](https://github.com/youssefhany-ixo)! - matrix fix
+
+## 1.0.3
+
+### Patch Changes
+
+- [`b5799ee`](https://github.com/ixoworld/companion/commit/b5799ee19a0957ad38e2374ae18e11278295a1ab) Thanks [@youssefhany-ixo](https://github.com/youssefhany-ixo)! - Fix testnet signed mnemonics
+
+## 1.0.2
+
+### Patch Changes
+
+- [#84](https://github.com/ixoworld/companion/pull/84) [`3117e8d`](https://github.com/ixoworld/companion/commit/3117e8d2f753811511de4eda8e99b18c3888e083) Thanks [@youssefhany-ixo](https://github.com/youssefhany-ixo)! - update
+
+## 1.0.1
+
+### Patch Changes
+
+- [#79](https://github.com/ixoworld/companion/pull/79) [`0fe4fab`](https://github.com/ixoworld/companion/commit/0fe4fabaea19e081cec76e740c2e935a92eae338) Thanks [@youssefhany-ixo](https://github.com/youssefhany-ixo)! - Add Gzip -- optmizeDB by removing unused indexes -- make token limit deduct more in devnet for easy tesing

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import { BaseCheckpointSaver, type Checkpoint, type CheckpointListOptions, type CheckpointMetadata, type CheckpointTuple, type PendingWrite, type SerializerProtocol } from '@langchain/langgraph-checkpoint';
+import { Database as DatabaseType, Statement } from 'better-sqlite3';
+interface Migration {
+    version: number;
+    name: string;
+    up: (db: DatabaseType) => void;
+}
+export declare class SqliteSaver extends BaseCheckpointSaver {
+    db: DatabaseType;
+    protected isSetup: boolean;
+    protected withoutCheckpoint: Statement;
+    protected withCheckpoint: Statement;
+    protected putCheckpointStmt: Statement;
+    protected putWritesStmt: Statement;
+    protected deleteCheckpointsStmt: Statement;
+    protected putMessageStmt: Statement;
+    protected getMessageStmt: Statement;
+    protected deleteWritesStmt: Statement;
+    constructor(db: DatabaseType, serde?: SerializerProtocol);
+    static fromConnString(connStringOrLocalPath: string): SqliteSaver;
+    static fromDatabase(db: DatabaseType, serde?: SerializerProtocol): SqliteSaver;
+    close(): void;
+    protected createSchemaMigrationsTable(): void;
+    protected getAppliedMigrations(): number[];
+    protected recordMigration(migration: Migration): void;
+    protected loadMigrations(): Migration[];
+    protected runMigrations(): void;
+    protected setup(): void;
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, _checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
+    putWrites(config: RunnableConfig, writes: PendingWrite[], taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+    protected migratePendingSends(checkpoint: Checkpoint, threadId: string, parentCheckpointId: string): Promise<void>;
+}
+export {};
+//# 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,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAGpB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EAExB,MAAM,iCAAiC,CAAC;AACzC,OAAiB,EAAE,QAAQ,IAAI,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAyD/E,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAC;CAChC;AA+ED,qBAAa,WAAY,SAAQ,mBAAmB;IAClD,EAAE,EAAE,YAAY,CAAC;IAEjB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAE3B,SAAS,CAAC,iBAAiB,EAAE,SAAS,CAAC;IAEvC,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC;IAEpC,SAAS,CAAC,iBAAiB,EAAE,SAAS,CAAC;IAEvC,SAAS,CAAC,aAAa,EAAE,SAAS,CAAC;IAEnC,SAAS,CAAC,qBAAqB,EAAE,SAAS,CAAC;IAC3C,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC;IAEpC,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC;IAEpC,SAAS,CAAC,gBAAgB,EAAE,SAAS,CAAC;gBAE1B,EAAE,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,kBAAkB;IAMxD,MAAM,CAAC,cAAc,CAAC,qBAAqB,EAAE,MAAM,GAAG,WAAW;IAIjE,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,kBAAkB,GAAG,WAAW;IAI9E,KAAK,IAAI,IAAI;IASb,SAAS,CAAC,2BAA2B,IAAI,IAAI;IAa7C,SAAS,CAAC,oBAAoB,IAAI,MAAM,EAAE;IAe1C,SAAS,CAAC,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAerD,SAAS,CAAC,cAAc,IAAI,SAAS,EAAE;IAiBvC,SAAS,CAAC,aAAa,IAAI,IAAI;IAoC/B,SAAS,CAAC,KAAK,IAAI,IAAI;IA8GjB,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAkGrE,IAAI,CACT,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAAC,eAAe,CAAC;IAyK5B,GAAG,CACP,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,UAAU,EACvB,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,CAAC;IA8GpB,SAAS,CACb,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,YAAY,EAAE,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IA8DV,YAAY,CAAC,QAAQ,EAAE,MAAM;cASnB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,MAAM;CAsC7B"}

package/dist/index.js

@@ -0,0 +1,567 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSaver = void 0;
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const _001_add_created_at_to_messages_1 = __importDefault(require("./migrations/001_add_created_at_to_messages"));
+const utils_1 = require("./utils");
+const checkpointMetadataKeys = ['source', 'step', 'parents'];
+function validateKeys(keys) {
+    return keys;
+}
+const validCheckpointMetadataKeys = validateKeys(checkpointMetadataKeys);
+function prepareSql(db, checkpointId) {
+    const sql = `
+  SELECT
+    thread_id,
+    checkpoint_ns,
+    checkpoint_id,
+    parent_checkpoint_id,
+    type,
+    checkpoint,
+    metadata,
+    (
+      SELECT
+        json_group_array(
+          json_object(
+            'task_id', pw.task_id,
+            'channel', pw.channel,
+            'type', pw.type,
+            'value', CAST(pw.value AS TEXT)
+          )
+        )
+      FROM writes as pw
+      WHERE pw.thread_id = checkpoints.thread_id
+        AND pw.checkpoint_ns = checkpoints.checkpoint_ns
+        AND pw.checkpoint_id = checkpoints.checkpoint_id
+    ) as pending_writes,
+    (
+      SELECT
+        json_group_array(
+          json_object(
+            'type', ps.type,
+            'value', CAST(ps.value AS TEXT)
+          )
+        )
+      FROM writes as ps
+      WHERE ps.thread_id = checkpoints.thread_id
+        AND ps.checkpoint_ns = checkpoints.checkpoint_ns
+        AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
+        AND ps.channel = '${langgraph_checkpoint_1.TASKS}'
+      ORDER BY ps.idx
+    ) as pending_sends
+  FROM checkpoints
+  WHERE thread_id = ? AND checkpoint_ns = ? ${checkpointId
+        ? 'AND checkpoint_id = ?'
+        : 'ORDER BY checkpoint_id DESC LIMIT 1'}`;
+    return db.prepare(sql);
+}
+class SqliteSaver extends langgraph_checkpoint_1.BaseCheckpointSaver {
+    db;
+    isSetup;
+    withoutCheckpoint;
+    withCheckpoint;
+    putCheckpointStmt;
+    putWritesStmt;
+    deleteCheckpointsStmt;
+    putMessageStmt;
+    getMessageStmt;
+    deleteWritesStmt;
+    constructor(db, serde) {
+        super(serde);
+        this.db = db;
+        this.isSetup = false;
+    }
+    static fromConnString(connStringOrLocalPath) {
+        return new SqliteSaver(new better_sqlite3_1.default(connStringOrLocalPath));
+    }
+    static fromDatabase(db, serde) {
+        return new SqliteSaver(db, serde);
+    }
+    close() {
+        if (this.db.open) {
+            this.db.close();
+        }
+    }
+    createSchemaMigrationsTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version INTEGER NOT NULL PRIMARY KEY,
+        name TEXT NOT NULL,
+        applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+    }
+    getAppliedMigrations() {
+        try {
+            const rows = this.db
+                .prepare('SELECT version FROM schema_migrations ORDER BY version')
+                .all();
+            return rows.map((row) => row.version);
+        }
+        catch {
+            return [];
+        }
+    }
+    recordMigration(migration) {
+        this.db
+            .prepare('INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, CURRENT_TIMESTAMP)')
+            .run(migration.version, migration.name);
+    }
+    loadMigrations() {
+        const migrations = [
+            _001_add_created_at_to_messages_1.default,
+        ];
+        migrations.sort((a, b) => a.version - b.version);
+        return migrations;
+    }
+    runMigrations() {
+        this.createSchemaMigrationsTable();
+        const appliedVersions = this.getAppliedMigrations();
+        const allMigrations = this.loadMigrations();
+        const pendingMigrations = allMigrations.filter((migration) => !appliedVersions.includes(migration.version));
+        if (pendingMigrations.length === 0) {
+            return;
+        }
+        console.log(`Running ${pendingMigrations.length} pending migration(s)...`);
+        for (const migration of pendingMigrations) {
+            try {
+                console.log(`Applying migration ${migration.version}: ${migration.name}`);
+                migration.up(this.db);
+                this.recordMigration(migration);
+                console.log(`✓ Migration ${migration.version}: ${migration.name} applied successfully`);
+            }
+            catch (error) {
+                console.error(`✗ Failed to apply migration ${migration.version}: ${migration.name}`, error);
+                throw error;
+            }
+        }
+    }
+    setup() {
+        if (this.isSetup) {
+            return;
+        }
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('busy_timeout = 5000');
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS 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,
+  metadata BLOB,
+  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+);`);
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS 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)
+);`);
+        this.db.exec(`
+CREATE TABLE IF NOT EXISTS messages (
+  thread_id TEXT NOT NULL,
+  checkpoint_ns TEXT NOT NULL DEFAULT '',
+  checkpoint_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  message_type TEXT NOT NULL,
+  message_content TEXT NOT NULL,
+  message BLOB,
+  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY  (message_id)
+    );
+`);
+        this.runMigrations();
+        this.db.exec(`
+CREATE INDEX IF NOT EXISTS idx_messages_thread_id 
+ON messages(thread_id);
+`);
+        this.db.exec(`
+CREATE INDEX IF NOT EXISTS idx_messages_checkpoint_id 
+ON messages(checkpoint_id);
+`);
+        this.db.exec(`
+CREATE INDEX IF NOT EXISTS idx_messages_lookup 
+ON messages(thread_id, checkpoint_ns, checkpoint_id);
+`);
+        this.db.exec(`
+CREATE INDEX IF NOT EXISTS idx_messages_thread_created 
+ON messages(thread_id, created_at);
+`);
+        this.db.exec(`
+CREATE INDEX IF NOT EXISTS idx_writes_channel 
+ON writes(thread_id, checkpoint_id, channel);
+`);
+        this.withoutCheckpoint = prepareSql(this.db, false);
+        this.withCheckpoint = prepareSql(this.db, true);
+        this.putCheckpointStmt = this.db.prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        this.putWritesStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO writes 
+      (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) 
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        this.deleteCheckpointsStmt = this.db.prepare(`DELETE FROM checkpoints WHERE thread_id = ?`);
+        this.deleteWritesStmt = this.db.prepare(`DELETE FROM writes WHERE thread_id = ?`);
+        this.putMessageStmt = this.db.prepare(`INSERT OR REPLACE INTO messages (thread_id, checkpoint_ns, checkpoint_id, message_id, message_type, message_content, message, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.getMessageStmt = this.db.prepare(`SELECT * FROM messages WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
+        this.isSetup = true;
+    }
+    async getTuple(config) {
+        this.setup();
+        const { thread_id, checkpoint_ns = '', checkpoint_id, } = config.configurable ?? {};
+        const args = [thread_id, checkpoint_ns];
+        if (checkpoint_id)
+            args.push(checkpoint_id);
+        const stm = checkpoint_id ? this.withCheckpoint : this.withoutCheckpoint;
+        const row = stm.get(...args);
+        if (row === undefined)
+            return undefined;
+        let finalConfig = config;
+        if (!checkpoint_id) {
+            finalConfig = {
+                configurable: {
+                    thread_id: row.thread_id,
+                    checkpoint_ns,
+                    checkpoint_id: row.checkpoint_id,
+                },
+            };
+        }
+        if (finalConfig.configurable?.thread_id === undefined ||
+            finalConfig.configurable?.checkpoint_id === undefined) {
+            throw new Error('Missing thread_id or checkpoint_id');
+        }
+        const messages = this.getMessageStmt.all(finalConfig.configurable?.thread_id, finalConfig.configurable?.checkpoint_ns, finalConfig.configurable?.checkpoint_id);
+        const pendingWrites = await Promise.all(JSON.parse(row.pending_writes).map(async (write) => {
+            return [
+                write.task_id,
+                write.channel,
+                await this.serde.loadsTyped(write.type ?? 'json', write.value ?? ''),
+            ];
+        }));
+        const parsedMessages = await Promise.all(messages.map(async (message) => {
+            return this.serde.loadsTyped('json', message.message);
+        }));
+        const checkpoint = (await this.serde.loadsTyped(row.type ?? 'json', row.checkpoint));
+        if (parsedMessages.length > 0) {
+            checkpoint.channel_values.messages = parsedMessages;
+        }
+        if (checkpoint.v < 4 && row.parent_checkpoint_id != null) {
+            await this.migratePendingSends(checkpoint, row.thread_id, row.parent_checkpoint_id);
+        }
+        return {
+            checkpoint,
+            config: finalConfig,
+            metadata: (await this.serde.loadsTyped(row.type ?? 'json', row.metadata)),
+            parentConfig: row.parent_checkpoint_id
+                ? {
+                    configurable: {
+                        thread_id: row.thread_id,
+                        checkpoint_ns,
+                        checkpoint_id: row.parent_checkpoint_id,
+                    },
+                }
+                : undefined,
+            pendingWrites,
+        };
+    }
+    async *list(config, options) {
+        const { limit, before, filter } = options ?? {};
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_ns = config.configurable?.checkpoint_ns;
+        let sql = `
+      SELECT
+        thread_id,
+        checkpoint_ns,
+        checkpoint_id,
+        parent_checkpoint_id,
+        type,
+        checkpoint,
+        metadata,
+        (
+          SELECT
+            json_group_array(
+              json_object(
+                'task_id', pw.task_id,
+                'channel', pw.channel,
+                'type', pw.type,
+                'value', CAST(pw.value AS TEXT)
+              )
+            )
+          FROM writes as pw
+          WHERE pw.thread_id = checkpoints.thread_id
+            AND pw.checkpoint_ns = checkpoints.checkpoint_ns
+            AND pw.checkpoint_id = checkpoints.checkpoint_id
+        ) as pending_writes,
+        (
+          SELECT
+            json_group_array(
+              json_object(
+                'type', ps.type,
+                'value', CAST(ps.value AS TEXT)
+              )
+            )
+          FROM writes as ps
+          WHERE ps.thread_id = checkpoints.thread_id
+            AND ps.checkpoint_ns = checkpoints.checkpoint_ns
+            AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
+            AND ps.channel = '${langgraph_checkpoint_1.TASKS}'
+          ORDER BY ps.idx
+        ) as pending_sends
+      FROM checkpoints\n`;
+        const whereClause = [];
+        if (thread_id) {
+            whereClause.push('thread_id = ?');
+        }
+        if (checkpoint_ns !== undefined && checkpoint_ns !== null) {
+            whereClause.push('checkpoint_ns = ?');
+        }
+        if (before?.configurable?.checkpoint_id !== undefined) {
+            whereClause.push('checkpoint_id < ?');
+        }
+        const sanitizedFilter = Object.fromEntries(Object.entries(filter ?? {}).filter(([key, value]) => value !== undefined &&
+            validCheckpointMetadataKeys.includes(key)));
+        whereClause.push(...Object.entries(sanitizedFilter).map(([key]) => `jsonb(CAST(metadata AS TEXT))->'$.${key}' = ?`));
+        if (whereClause.length > 0) {
+            sql += `WHERE\n  ${whereClause.join(' AND\n  ')}\n`;
+        }
+        sql += '\nORDER BY checkpoint_id DESC';
+        if (limit) {
+            sql += ` LIMIT ${parseInt(limit, 10)}`;
+        }
+        const args = [
+            thread_id,
+            checkpoint_ns,
+            before?.configurable?.checkpoint_id,
+            ...Object.values(sanitizedFilter).map((value) => JSON.stringify(value)),
+        ].filter((value) => value !== undefined && value !== null);
+        const rows = this.db
+            .prepare(sql)
+            .all(...args);
+        if (rows) {
+            for (const row of rows) {
+                const pendingWrites = await Promise.all(JSON.parse(row.pending_writes).map(async (write) => {
+                    return [
+                        write.task_id,
+                        write.channel,
+                        await this.serde.loadsTyped(write.type ?? 'json', write.value ?? ''),
+                    ];
+                }));
+                const messages = this.getMessageStmt.all(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
+                const parsedMessages = await Promise.all(messages.map(async (message) => {
+                    return this.serde.loadsTyped('json', message.message);
+                }));
+                const checkpoint = (await this.serde.loadsTyped(row.type ?? 'json', row.checkpoint));
+                if (parsedMessages.length > 0) {
+                    checkpoint.channel_values.messages = parsedMessages;
+                }
+                if (checkpoint.v < 4 && row.parent_checkpoint_id != null) {
+                    await this.migratePendingSends(checkpoint, row.thread_id, row.parent_checkpoint_id);
+                }
+                yield {
+                    config: {
+                        configurable: {
+                            thread_id: row.thread_id,
+                            checkpoint_ns: row.checkpoint_ns,
+                            checkpoint_id: row.checkpoint_id,
+                        },
+                    },
+                    checkpoint,
+                    metadata: (await this.serde.loadsTyped(row.type ?? 'json', row.metadata)),
+                    parentConfig: row.parent_checkpoint_id
+                        ? {
+                            configurable: {
+                                thread_id: row.thread_id,
+                                checkpoint_ns: row.checkpoint_ns,
+                                checkpoint_id: row.parent_checkpoint_id,
+                            },
+                        }
+                        : undefined,
+                    pendingWrites,
+                };
+            }
+        }
+    }
+    async put(config, _checkpoint, metadata) {
+        this.setup();
+        if (!config.configurable) {
+            throw new Error('Empty configuration supplied.');
+        }
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_ns = config.configurable?.checkpoint_ns ?? '';
+        const parent_checkpoint_id = config.configurable?.checkpoint_id;
+        if (!thread_id) {
+            throw new Error(`Missing "thread_id" field in passed "config.configurable".`);
+        }
+        const { checkpoint, messages } = removeMessagesFromCheckpoint(_checkpoint);
+        const [[type1, serializedCheckpoint], [type2, serializedMetadata]] = await Promise.all([
+            this.serde.dumpsTyped(checkpoint),
+            this.serde.dumpsTyped(metadata),
+        ]);
+        if (type1 !== type2) {
+            throw new Error('Failed to serialized checkpoint and metadata to the same type.');
+        }
+        const row = [
+            thread_id,
+            checkpoint_ns,
+            checkpoint.id,
+            parent_checkpoint_id,
+            type1,
+            serializedCheckpoint,
+            serializedMetadata,
+        ];
+        const transaction = this.db.transaction(() => {
+            this.putCheckpointStmt.run(...row);
+            if (messages) {
+                for (const message of messages) {
+                    const encoder = new TextEncoder();
+                    const msgFromMatrixRoom = message.additional_kwargs
+                        .msgFromMatrixRoom;
+                    const _additionalKwargs = message.additional_kwargs;
+                    const cleanedAdditionalKwargs = (0, utils_1.cleanAdditionalKwargs)(message.additional_kwargs, msgFromMatrixRoom ?? false);
+                    message.additional_kwargs = {
+                        ...cleanedAdditionalKwargs,
+                        reasoning: cleanedAdditionalKwargs.reasoning ?? _additionalKwargs.reasoning,
+                        reasoningDetails: cleanedAdditionalKwargs.reasoningDetails ??
+                            _additionalKwargs.reasoningDetails,
+                    };
+                    if (message.type !== 'ai') {
+                        delete message.additional_kwargs.reasoning;
+                        delete message.additional_kwargs.reasoningDetails;
+                    }
+                    const serializedMessage = encoder.encode((0, utils_1.stringify)(message, (_, value) => {
+                        return (0, utils_1._default)(value);
+                    }));
+                    const messageRow = {
+                        thread_id,
+                        checkpoint_ns,
+                        checkpoint_id: checkpoint.id,
+                        message_id: message.id ?? message.lc_kwargs?.id,
+                        message_type: message.type,
+                        message_content: message.content.toString(),
+                        message: serializedMessage,
+                        created_at: message.additional_kwargs?.timestamp ??
+                            new Date().toISOString(),
+                    };
+                    this.putMessageStmt.run(messageRow.thread_id, messageRow.checkpoint_ns, messageRow.checkpoint_id, messageRow.message_id, messageRow.message_type, messageRow.message_content, messageRow.message, messageRow.created_at);
+                }
+            }
+        });
+        transaction();
+        return {
+            configurable: {
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id: checkpoint.id,
+            },
+        };
+    }
+    async putWrites(config, writes, taskId) {
+        this.setup();
+        if (!config.configurable) {
+            throw new Error('Empty configuration supplied.');
+        }
+        if (!config.configurable?.thread_id) {
+            console.error('Missing thread_id field in config.configurable.', {
+                configurable: config.configurable,
+            });
+            const threadId = this.db
+                .prepare('SELECT thread_id FROM checkpoints WHERE checkpoint_id = ?')
+                .get(config.configurable?.checkpoint_id);
+            if (!threadId) {
+                throw new Error('Missing thread_id field in config.configurable. config: ' +
+                    JSON.stringify(config.configurable));
+            }
+            config.configurable.thread_id = threadId.thread_id;
+        }
+        if (!config.configurable?.checkpoint_id) {
+            console.error('Missing checkpoint_id field in config.configurable.', {
+                configurable: config.configurable,
+            });
+            throw new Error('Missing checkpoint_id field in config.configurable. config: ' +
+                JSON.stringify(config.configurable));
+        }
+        const transaction = this.db.transaction((rows) => {
+            for (const row of rows) {
+                this.putWritesStmt.run(...row);
+            }
+        });
+        const rows = await Promise.all(writes.map(async (write, idx) => {
+            const [type, serializedWrite] = await this.serde.dumpsTyped(write[1]);
+            return [
+                config.configurable?.thread_id,
+                config.configurable?.checkpoint_ns,
+                config.configurable?.checkpoint_id,
+                taskId,
+                idx,
+                write[0],
+                type,
+                serializedWrite,
+            ];
+        }));
+        transaction(rows);
+    }
+    async deleteThread(threadId) {
+        const transaction = this.db.transaction(() => {
+            this.deleteCheckpointsStmt.run(threadId);
+            this.deleteWritesStmt.run(threadId);
+        });
+        transaction();
+    }
+    async migratePendingSends(checkpoint, threadId, parentCheckpointId) {
+        const { pending_sends } = this.db
+            .prepare(`
+          SELECT
+            checkpoint_id,
+            json_group_array(
+              json_object(
+                'type', ps.type,
+                'value', CAST(ps.value AS TEXT)
+              )
+            ) as pending_sends
+          FROM writes as ps
+          WHERE ps.thread_id = ?
+            AND ps.checkpoint_id = ?
+            AND ps.channel = '${langgraph_checkpoint_1.TASKS}'
+          ORDER BY ps.idx
+        `)
+            .get(threadId, parentCheckpointId);
+        const mutableCheckpoint = checkpoint;
+        mutableCheckpoint.channel_values ??= {};
+        mutableCheckpoint.channel_values[langgraph_checkpoint_1.TASKS] = await Promise.all(JSON.parse(pending_sends).map(({ type, value }) => this.serde.loadsTyped(type, value)));
+        mutableCheckpoint.channel_versions[langgraph_checkpoint_1.TASKS] =
+            Object.keys(checkpoint.channel_versions).length > 0
+                ? (0, langgraph_checkpoint_1.maxChannelVersion)(...Object.values(checkpoint.channel_versions))
+                : this.getNextVersion(undefined);
+    }
+}
+exports.SqliteSaver = SqliteSaver;
+const isCheckpointWithMessages = (checkpoint) => {
+    return 'messages' in checkpoint.channel_values;
+};
+const removeMessagesFromCheckpoint = (checkpoint) => {
+    if (isCheckpointWithMessages(checkpoint)) {
+        const newCheckpoint = (0, langgraph_checkpoint_1.copyCheckpoint)(checkpoint);
+        delete newCheckpoint.channel_values.messages;
+        return {
+            checkpoint: newCheckpoint,
+            messages: checkpoint.channel_values.messages,
+        };
+    }
+    return {
+        checkpoint,
+        messages: undefined,
+    };
+};
+//# sourceMappingURL=index.js.map