@langgraph-js/pure-graph 1.2.0 → 1.4.0

package/dist/storage/pg/threads.js

@@ -0,0 +1,304 @@
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class PostgresThreadsManager {
+    pool;
+    isSetup = false;
+    constructor(checkpointer) {
+        // 访问 PostgresSaver 的 pool 属性（虽然是 private，但在运行时可以访问）
+        this.pool = checkpointer.pool;
+        this.setup();
+    }
+    async setup() {
+        if (this.isSetup) {
+            return;
+        }
+        // 创建 threads 表
+        await this.pool.query(`
+            CREATE TABLE IF NOT EXISTS threads (
+                thread_id TEXT PRIMARY KEY,
+                created_at TIMESTAMP NOT NULL,
+                updated_at TIMESTAMP NOT NULL,
+                metadata JSONB NOT NULL DEFAULT '{}',
+                status TEXT NOT NULL DEFAULT 'idle',
+                "values" JSONB,
+                interrupts JSONB NOT NULL DEFAULT '{}'
+            )
+        `);
+        // 创建 runs 表
+        await this.pool.query(`
+            CREATE TABLE IF NOT EXISTS runs (
+                run_id TEXT PRIMARY KEY,
+                thread_id TEXT NOT NULL,
+                assistant_id TEXT NOT NULL,
+                created_at TIMESTAMP NOT NULL,
+                updated_at TIMESTAMP NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                metadata JSONB NOT NULL DEFAULT '{}',
+                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
+                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+            )
+        `);
+        // 创建索引以提高查询性能
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
+        await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
+        await this.pool.query(`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 result = await this.pool.query('SELECT thread_id FROM threads WHERE thread_id = $1', [threadId]);
+            if (result.rows.length > 0) {
+                throw new Error(`Thread with ID ${threadId} already exists.`);
+            }
+        }
+        const now = new Date();
+        const metadata = payload?.metadata || {};
+        const interrupts = {};
+        const thread = {
+            thread_id: threadId,
+            created_at: now.toISOString(),
+            updated_at: now.toISOString(),
+            metadata,
+            status: 'idle',
+            values: null,
+            interrupts,
+        };
+        // 插入到数据库
+        await this.pool.query(`
+            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, "values", interrupts)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+        `, [threadId, now, now, JSON.stringify(metadata), 'idle', null, JSON.stringify(interrupts)]);
+        return thread;
+    }
+    async search(query) {
+        let sql = 'SELECT * FROM threads';
+        const whereConditions = [];
+        const params = [];
+        let paramIndex = 1;
+        // 构建 WHERE 条件
+        if (query?.status) {
+            whereConditions.push(`status = $${paramIndex++}`);
+            params.push(query.status);
+        }
+        if (query?.metadata) {
+            for (const [key, value] of Object.entries(query.metadata)) {
+                whereConditions.push(`metadata->$${paramIndex} = $${paramIndex + 1}`);
+                params.push(key, JSON.stringify(value));
+                paramIndex += 2;
+            }
+        }
+        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 $${paramIndex++}`;
+            params.push(query.limit);
+            if (query?.offset) {
+                sql += ` OFFSET $${paramIndex++}`;
+                params.push(query.offset);
+            }
+        }
+        const result = await this.pool.query(sql, params);
+        return result.rows.map((row) => ({
+            thread_id: row.thread_id,
+            created_at: new Date(row.created_at).toISOString(),
+            updated_at: new Date(row.updated_at).toISOString(),
+            metadata: row.metadata,
+            status: row.status,
+            values: row.values || null,
+            interrupts: row.interrupts,
+        }));
+    }
+    async get(threadId) {
+        const result = await this.pool.query('SELECT * FROM threads WHERE thread_id = $1', [threadId]);
+        if (result.rows.length === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const row = result.rows[0];
+        return {
+            thread_id: row.thread_id,
+            created_at: new Date(row.created_at).toISOString(),
+            updated_at: new Date(row.updated_at).toISOString(),
+            metadata: row.metadata,
+            status: row.status,
+            values: row.values || null,
+            interrupts: row.interrupts,
+        };
+    }
+    async set(threadId, thread) {
+        // 检查线程是否存在
+        const existingThread = await this.pool.query('SELECT thread_id FROM threads WHERE thread_id = $1', [threadId]);
+        if (existingThread.rows.length === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const updateFields = [];
+        const values = [];
+        let paramIndex = 1;
+        if (thread.metadata !== undefined) {
+            updateFields.push(`metadata = $${paramIndex++}`);
+            values.push(JSON.stringify(thread.metadata));
+        }
+        if (thread.status !== undefined) {
+            updateFields.push(`status = $${paramIndex++}`);
+            values.push(thread.status);
+        }
+        if (thread.values !== undefined) {
+            updateFields.push(`"values" = $${paramIndex++}`);
+            values.push(thread.values ? JSON.stringify(thread.values) : null);
+        }
+        if (thread.interrupts !== undefined) {
+            updateFields.push(`interrupts = $${paramIndex++}`);
+            values.push(JSON.stringify(thread.interrupts));
+        }
+        // 总是更新 updated_at
+        updateFields.push(`updated_at = $${paramIndex++}`);
+        values.push(new Date());
+        if (updateFields.length > 0) {
+            values.push(threadId);
+            await this.pool.query(`
+                UPDATE threads 
+                SET ${updateFields.join(', ')} 
+                WHERE thread_id = $${paramIndex}
+            `, values);
+        }
+    }
+    async updateState(threadId, thread) {
+        // 从数据库查询线程信息
+        const result = await this.pool.query('SELECT * FROM threads WHERE thread_id = $1', [threadId]);
+        if (result.rows.length === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const row = result.rows[0];
+        const targetThread = {
+            thread_id: row.thread_id,
+            created_at: new Date(row.created_at).toISOString(),
+            updated_at: new Date(row.updated_at).toISOString(),
+            metadata: row.metadata,
+            status: row.status,
+            values: row.values || null,
+            interrupts: row.interrupts,
+        };
+        if (targetThread.status === 'busy') {
+            throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+        }
+        if (!targetThread.metadata?.graph_id) {
+            throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+        }
+        const graphId = targetThread.metadata?.graph_id;
+        const config = {
+            configurable: {
+                thread_id: threadId,
+                graph_id: graphId,
+            },
+        };
+        const graph = await getGraph(graphId, config);
+        const nextConfig = await graph.updateState(config, thread.values);
+        const graphState = await graph.getState(config);
+        await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
+        return nextConfig;
+    }
+    async delete(threadId) {
+        const result = await this.pool.query('DELETE FROM threads WHERE thread_id = $1', [threadId]);
+        if (result.rowCount === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+    }
+    async createRun(threadId, assistantId, payload) {
+        const runId = crypto.randomUUID();
+        const now = new Date();
+        const metadata = payload?.metadata ?? {};
+        const run = {
+            run_id: runId,
+            thread_id: threadId,
+            assistant_id: assistantId,
+            created_at: now.toISOString(),
+            updated_at: now.toISOString(),
+            status: 'pending',
+            metadata,
+            multitask_strategy: 'reject',
+        };
+        // 插入到数据库
+        await this.pool.query(`
+            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+        `, [runId, threadId, assistantId, now, now, 'pending', JSON.stringify(metadata), 'reject']);
+        return run;
+    }
+    async listRuns(threadId, options) {
+        let sql = 'SELECT * FROM runs WHERE thread_id = $1';
+        const params = [threadId];
+        let paramIndex = 2;
+        if (options?.status) {
+            sql += ` AND status = $${paramIndex++}`;
+            params.push(options.status);
+        }
+        sql += ' ORDER BY created_at DESC';
+        if (options?.limit) {
+            sql += ` LIMIT $${paramIndex++}`;
+            params.push(options.limit);
+            if (options?.offset) {
+                sql += ` OFFSET $${paramIndex++}`;
+                params.push(options.offset);
+            }
+        }
+        const result = await this.pool.query(sql, params);
+        return result.rows.map((row) => ({
+            run_id: row.run_id,
+            thread_id: row.thread_id,
+            assistant_id: row.assistant_id,
+            created_at: new Date(row.created_at).toISOString(),
+            updated_at: new Date(row.updated_at).toISOString(),
+            status: row.status,
+            metadata: row.metadata,
+            multitask_strategy: row.multitask_strategy,
+        }));
+    }
+    async updateRun(runId, run) {
+        // 检查运行是否存在
+        const existingRun = await this.pool.query('SELECT run_id FROM runs WHERE run_id = $1', [runId]);
+        if (existingRun.rows.length === 0) {
+            throw new Error(`Run with ID ${runId} not found.`);
+        }
+        const updateFields = [];
+        const values = [];
+        let paramIndex = 1;
+        if (run.status !== undefined) {
+            updateFields.push(`status = $${paramIndex++}`);
+            values.push(run.status);
+        }
+        if (run.metadata !== undefined) {
+            updateFields.push(`metadata = $${paramIndex++}`);
+            values.push(JSON.stringify(run.metadata));
+        }
+        if (run.multitask_strategy !== undefined) {
+            updateFields.push(`multitask_strategy = $${paramIndex++}`);
+            values.push(run.multitask_strategy);
+        }
+        // 总是更新 updated_at
+        updateFields.push(`updated_at = $${paramIndex++}`);
+        values.push(new Date());
+        if (updateFields.length > 0) {
+            values.push(runId);
+            await this.pool.query(`
+                UPDATE runs 
+                SET ${updateFields.join(', ')} 
+                WHERE run_id = $${paramIndex}
+            `, values);
+        }
+    }
+}

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

@@ -1,8 +1,8 @@
 import { BaseThreadsManager } from '../../threads/index.js';
-import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+import { Command, Config, 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 {
+export declare class SQLiteThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
     db: DatabaseType;
     private isSetup;
     constructor(checkpointer: SqliteSaver);
@@ -30,6 +30,7 @@ export declare class SQLiteThreadsManager<ValuesType = unknown> extends BaseThre
     }): Promise<Thread<ValuesType>[]>;
     get(threadId: string): Promise<Thread<ValuesType>>;
     set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void>;
+    updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>>;
     delete(threadId: string): Promise<void>;
     createRun(threadId: string, assistantId: string, payload?: {
         metadata?: Metadata;

package/dist/storage/sqlite/threads.js

@@ -1,9 +1,9 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-export class SQLiteThreadsManager extends BaseThreadsManager {
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class SQLiteThreadsManager {
     db;
     isSetup = false;
     constructor(checkpointer) {
-        super();
         this.db = checkpointer.db;
         this.setup();
     }
@@ -174,6 +174,40 @@ export class SQLiteThreadsManager extends BaseThreadsManager {
                 .run(...values);
         }
     }
+    async updateState(threadId, thread) {
+        // 从数据库查询线程信息
+        const row = this.db.prepare('SELECT * FROM threads WHERE thread_id = ?').get(threadId);
+        if (!row) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const targetThread = {
+            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),
+        };
+        if (targetThread.status === 'busy') {
+            throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+        }
+        if (!targetThread.metadata?.graph_id) {
+            throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+        }
+        const graphId = targetThread.metadata?.graph_id;
+        const config = {
+            configurable: {
+                thread_id: threadId,
+                graph_id: graphId,
+            },
+        };
+        const graph = await getGraph(graphId, config);
+        const nextConfig = await graph.updateState(config, thread.values);
+        const graphState = await graph.getState(config);
+        await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
+        return nextConfig;
+    }
     async delete(threadId) {
         const result = this.db.prepare('DELETE FROM threads WHERE thread_id = ?').run(threadId);
         if (result.changes === 0) {

package/dist/threads/index.d.ts

@@ -1,5 +1,5 @@
-import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
-export declare class BaseThreadsManager<ValuesType = unknown> {
+import { Command, Config, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+export interface BaseThreadsManager<ValuesType = unknown> {
     create(payload?: {
         metadata?: Metadata;
         threadId?: string;
@@ -24,6 +24,7 @@ export declare class BaseThreadsManager<ValuesType = unknown> {
     }): Promise<Thread<ValuesType>[]>;
     get(threadId: string): Promise<Thread<ValuesType>>;
     delete(threadId: string): Promise<void>;
+    updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>>;
     createRun(threadId: string, assistantId: string, payload?: {
         metadata?: Metadata;
     }): Promise<Run>;

package/dist/threads/index.js

@@ -1,26 +1 @@
-export class BaseThreadsManager {
-    create(payload) {
-        throw new Error('Function not implemented.');
-    }
-    set(threadId, thread) {
-        throw new Error('Function not implemented.');
-    }
-    search(query) {
-        throw new Error('Function not implemented.');
-    }
-    get(threadId) {
-        throw new Error('Function not implemented.');
-    }
-    delete(threadId) {
-        throw new Error('Function not implemented.');
-    }
-    createRun(threadId, assistantId, payload) {
-        throw new Error('Function not implemented.');
-    }
-    listRuns(threadId, options) {
-        throw new Error('Function not implemented.');
-    }
-    updateRun(runId, run) {
-        throw new Error('Function not implemented.');
-    }
-}
+export {};