@langgraph-js/pure-graph 1.0.2 → 1.2.0

package/dist/storage/sqlite/checkpoint.js

@@ -0,0 +1,374 @@
+import { Database } from './DB.js';
+import { BaseCheckpointSaver, TASKS, copyCheckpoint, maxChannelVersion, } from '@langchain/langgraph-checkpoint';
+// In the `SqliteSaver.list` method, we need to sanitize the `options.filter` argument to ensure it only contains keys
+// that are part of the `CheckpointMetadata` type. The lines below ensure that we get compile-time errors if the list
+// of keys that we use is out of sync with the `CheckpointMetadata` type.
+const checkpointMetadataKeys = ['source', 'step', 'parents'];
+function validateKeys(keys) {
+    return keys;
+}
+// If this line fails to compile, the list of keys that we use in the `SqliteSaver.list` method is out of sync with the
+// `CheckpointMetadata` type. In that case, just update `checkpointMetadataKeys` to contain all the keys in
+// `CheckpointMetadata`
+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 = '${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);
+}
+export class SqliteSaver extends BaseCheckpointSaver {
+    db;
+    isSetup;
+    withoutCheckpoint;
+    withCheckpoint;
+    constructor(db, serde) {
+        super(serde);
+        this.db = db;
+        this.isSetup = false;
+    }
+    static fromConnString(connStringOrLocalPath) {
+        return new SqliteSaver(new Database(connStringOrLocalPath));
+    }
+    setup() {
+        if (this.isSetup) {
+            return;
+        }
+        // this.db.pragma('journal_mode=WAL');
+        this.db.exec('PRAGMA journal_mode = WAL;');
+        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.withoutCheckpoint = prepareSql(this.db, false);
+        this.withCheckpoint = prepareSql(this.db, true);
+        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 || row === null)
+            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 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 checkpoint = (await this.serde.loadsTyped(row.type ?? 'json', row.checkpoint));
+        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 = '${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) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sql += ` LIMIT ${parseInt(limit, 10)}`; // parseInt here (with cast to make TS happy) to sanitize input, as limit may be user-provided
+        }
+        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 checkpoint = (await this.serde.loadsTyped(row.type ?? 'json', row.checkpoint));
+                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 preparedCheckpoint = copyCheckpoint(checkpoint);
+        const [[type1, serializedCheckpoint], [type2, serializedMetadata]] = await Promise.all([
+            this.serde.dumpsTyped(preparedCheckpoint),
+            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,
+        ];
+        this.db
+            .prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(...row);
+        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) {
+            throw new Error('Missing thread_id field in config.configurable.');
+        }
+        if (!config.configurable?.checkpoint_id) {
+            throw new Error('Missing checkpoint_id field in config.configurable.');
+        }
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO writes 
+      (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) 
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const transaction = this.db.transaction((rows) => {
+            for (const row of rows) {
+                stmt.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.db.prepare(`DELETE FROM checkpoints WHERE thread_id = ?`).run(threadId);
+            this.db.prepare(`DELETE FROM writes WHERE thread_id = ?`).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 = '${TASKS}'
+          ORDER BY ps.idx
+        `)
+            .get(threadId, parentCheckpointId);
+        const mutableCheckpoint = checkpoint;
+        // add pending sends to checkpoint
+        mutableCheckpoint.channel_values ??= {};
+        mutableCheckpoint.channel_values[TASKS] = await Promise.all(JSON.parse(pending_sends).map(({ type, value }) => this.serde.loadsTyped(type, value)));
+        // add to versions
+        mutableCheckpoint.channel_versions[TASKS] =
+            Object.keys(checkpoint.channel_versions).length > 0
+                ? maxChannelVersion(...Object.values(checkpoint.channel_versions))
+                : this.getNextVersion(undefined);
+    }
+}

package/dist/storage/sqlite/threads.d.ts

@@ -0,0 +1,43 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+import type { SqliteSaver } from './checkpoint.js';
+import type { DatabaseType } from './type.js';
+export declare class SQLiteThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+    db: DatabaseType;
+    private isSetup;
+    constructor(checkpointer: SqliteSaver);
+    private setup;
+    create(payload?: {
+        metadata?: Metadata;
+        threadId?: string;
+        ifExists?: OnConflictBehavior;
+        graphId?: string;
+        supersteps?: Array<{
+            updates: Array<{
+                values: unknown;
+                command?: Command;
+                asNode: string;
+            }>;
+        }>;
+    }): Promise<Thread<ValuesType>>;
+    search(query?: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+        status?: ThreadStatus;
+        sortBy?: ThreadSortBy;
+        sortOrder?: SortOrder;
+    }): Promise<Thread<ValuesType>[]>;
+    get(threadId: string): Promise<Thread<ValuesType>>;
+    set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void>;
+    delete(threadId: string): Promise<void>;
+    createRun(threadId: string, assistantId: string, payload?: {
+        metadata?: Metadata;
+    }): Promise<Run>;
+    listRuns(threadId: string, options?: {
+        limit?: number;
+        offset?: number;
+        status?: RunStatus;
+    }): Promise<Run[]>;
+    updateRun(runId: string, run: Partial<Run>): Promise<void>;
+}

package/dist/storage/sqlite/threads.js

@@ -0,0 +1,266 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+export class SQLiteThreadsManager extends BaseThreadsManager {
+    db;
+    isSetup = false;
+    constructor(checkpointer) {
+        super();
+        this.db = checkpointer.db;
+        this.setup();
+    }
+    setup() {
+        if (this.isSetup) {
+            return;
+        }
+        // 创建 threads 表
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS 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',
+                [values] TEXT,
+                interrupts TEXT NOT NULL DEFAULT '{}'
+            )
+        `);
+        // 创建 runs 表
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS runs (
+                run_id TEXT PRIMARY KEY,
+                thread_id TEXT NOT NULL,
+                assistant_id TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                metadata TEXT NOT NULL DEFAULT '{}',
+                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
+                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+            )
+        `);
+        // 创建索引以提高查询性能
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
+        this.isSetup = true;
+    }
+    async create(payload) {
+        const threadId = payload?.threadId || crypto.randomUUID();
+        // 检查线程是否已存在
+        if (payload?.ifExists === 'raise') {
+            const existingThread = this.db.prepare('SELECT thread_id FROM threads WHERE thread_id = ?').get(threadId);
+            if (existingThread) {
+                throw new Error(`Thread with ID ${threadId} already exists.`);
+            }
+        }
+        const now = new Date().toISOString();
+        const metadata = JSON.stringify(payload?.metadata || {});
+        const interrupts = JSON.stringify({});
+        const thread = {
+            thread_id: threadId,
+            created_at: now,
+            updated_at: now,
+            metadata: payload?.metadata || {},
+            status: 'idle',
+            values: null,
+            interrupts: {},
+        };
+        // 插入到数据库
+        this.db
+            .prepare(`
+            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, [values], interrupts)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `)
+            .run(threadId, now, now, metadata, 'idle', null, interrupts);
+        return thread;
+    }
+    async search(query) {
+        let sql = 'SELECT * FROM threads';
+        const whereConditions = [];
+        const params = [];
+        // 构建 WHERE 条件
+        if (query?.status) {
+            whereConditions.push('status = ?');
+            params.push(query.status);
+        }
+        if (query?.metadata) {
+            for (const [key, value] of Object.entries(query.metadata)) {
+                whereConditions.push(`json_extract(metadata, '$.${key}') = ?`);
+                params.push(JSON.stringify(value));
+            }
+        }
+        if (whereConditions.length > 0) {
+            sql += ' WHERE ' + whereConditions.join(' AND ');
+        }
+        // 添加排序
+        if (query?.sortBy) {
+            sql += ` ORDER BY ${query.sortBy}`;
+            if (query.sortOrder === 'desc') {
+                sql += ' DESC';
+            }
+            else {
+                sql += ' ASC';
+            }
+        }
+        // 添加分页
+        if (query?.limit) {
+            sql += ` LIMIT ${query.limit}`;
+            if (query?.offset) {
+                sql += ` OFFSET ${query.offset}`;
+            }
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => ({
+            thread_id: row.thread_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            metadata: JSON.parse(row.metadata),
+            status: row.status,
+            values: row.values ? JSON.parse(row.values) : null,
+            interrupts: JSON.parse(row.interrupts),
+        }));
+    }
+    async get(threadId) {
+        const row = this.db.prepare('SELECT * FROM threads WHERE thread_id = ?').get(threadId);
+        if (!row) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        return {
+            thread_id: row.thread_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            metadata: JSON.parse(row.metadata),
+            status: row.status,
+            values: row.values ? JSON.parse(row.values) : null,
+            interrupts: JSON.parse(row.interrupts),
+        };
+    }
+    async set(threadId, thread) {
+        // 检查线程是否存在
+        const existingThread = this.db.prepare('SELECT thread_id FROM threads WHERE thread_id = ?').get(threadId);
+        if (!existingThread) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const updateFields = [];
+        const values = [];
+        if (thread.metadata !== undefined) {
+            updateFields.push('metadata = ?');
+            values.push(JSON.stringify(thread.metadata));
+        }
+        if (thread.status !== undefined) {
+            updateFields.push('status = ?');
+            values.push(thread.status);
+        }
+        if (thread.values !== undefined) {
+            updateFields.push('[values] = ?');
+            values.push(thread.values ? JSON.stringify(thread.values) : null);
+        }
+        if (thread.interrupts !== undefined) {
+            updateFields.push('interrupts = ?');
+            values.push(JSON.stringify(thread.interrupts));
+        }
+        // 总是更新 updated_at
+        updateFields.push('updated_at = ?');
+        values.push(new Date().toISOString());
+        if (updateFields.length > 0) {
+            values.push(threadId);
+            this.db
+                .prepare(`
+                UPDATE threads 
+                SET ${updateFields.join(', ')} 
+                WHERE thread_id = ?
+            `)
+                .run(...values);
+        }
+    }
+    async delete(threadId) {
+        const result = this.db.prepare('DELETE FROM threads WHERE thread_id = ?').run(threadId);
+        if (result.changes === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+    }
+    async createRun(threadId, assistantId, payload) {
+        const runId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const metadata = JSON.stringify(payload?.metadata ?? {});
+        const run = {
+            run_id: runId,
+            thread_id: threadId,
+            assistant_id: assistantId,
+            created_at: now,
+            updated_at: now,
+            status: 'pending',
+            metadata: payload?.metadata ?? {},
+            multitask_strategy: 'reject',
+        };
+        // 插入到数据库
+        this.db
+            .prepare(`
+            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+            .run(runId, threadId, assistantId, now, now, 'pending', metadata, 'reject');
+        return run;
+    }
+    async listRuns(threadId, options) {
+        let sql = 'SELECT * FROM runs WHERE thread_id = ?';
+        const params = [threadId];
+        if (options?.status) {
+            sql += ' AND status = ?';
+            params.push(options.status);
+        }
+        sql += ' ORDER BY created_at DESC';
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+            if (options?.offset) {
+                sql += ` OFFSET ${options.offset}`;
+            }
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => ({
+            run_id: row.run_id,
+            thread_id: row.thread_id,
+            assistant_id: row.assistant_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            status: row.status,
+            metadata: JSON.parse(row.metadata),
+            multitask_strategy: row.multitask_strategy,
+        }));
+    }
+    async updateRun(runId, run) {
+        // 检查运行是否存在
+        const existingRun = this.db.prepare('SELECT run_id FROM runs WHERE run_id = ?').get(runId);
+        if (!existingRun) {
+            throw new Error(`Run with ID ${runId} not found.`);
+        }
+        const updateFields = [];
+        const values = [];
+        if (run.status !== undefined) {
+            updateFields.push('status = ?');
+            values.push(run.status);
+        }
+        if (run.metadata !== undefined) {
+            updateFields.push('metadata = ?');
+            values.push(JSON.stringify(run.metadata));
+        }
+        if (run.multitask_strategy !== undefined) {
+            updateFields.push('multitask_strategy = ?');
+            values.push(run.multitask_strategy);
+        }
+        // 总是更新 updated_at
+        updateFields.push('updated_at = ?');
+        values.push(new Date().toISOString());
+        if (updateFields.length > 0) {
+            values.push(runId);
+            this.db
+                .prepare(`
+                UPDATE runs 
+                SET ${updateFields.join(', ')} 
+                WHERE run_id = ?
+            `)
+                .run(...values);
+        }
+    }
+}

package/dist/storage/sqlite/type.d.ts

@@ -0,0 +1,15 @@
+export interface DatabaseType {
+    prepare(sql: string): Statement;
+    exec(sql: string): void;
+    close(): void;
+    transaction<T extends any[]>(fn: (...args: T) => void): (...args: T) => void;
+}
+interface Statement {
+    run(...params: any[]): {
+        changes: number;
+        lastInsertRowid: number;
+    };
+    get(...params: any[]): any;
+    all(...params: any[]): any[];
+}
+export {};

package/dist/storage/sqlite/type.js

@@ -0,0 +1 @@
+export {};