@langgraph-js/pure-graph 1.4.2 → 1.4.5

package/dist/storage/index.js

@@ -1,64 +0,0 @@
-import { StreamQueueManager } from '../queue/stream_queue';
-import { MemorySaver } from './memory/checkpoint';
-import { MemoryStreamQueue } from './memory/queue';
-import { MemoryThreadsManager } from './memory/threads';
-import { SQLiteThreadsManager } from './sqlite/threads';
-// 所有的适配实现，都请写到这里，通过环境变量进行判断使用哪种方式进行适配
-export const createCheckPointer = async () => {
-    if ((process.env.REDIS_URL && process.env.CHECKPOINT_TYPE === 'redis') ||
-        process.env.CHECKPOINT_TYPE === 'shallow/redis') {
-        if (process.env.CHECKPOINT_TYPE === 'redis') {
-            console.debug('LG | Using redis as checkpoint');
-            const { RedisSaver } = await import('@langchain/langgraph-checkpoint-redis');
-            return await RedisSaver.fromUrl(process.env.REDIS_URL, {
-                defaultTTL: 60, // TTL in minutes
-                refreshOnRead: true,
-            });
-        }
-        if (process.env.CHECKPOINT_TYPE === 'shallow/redis') {
-            console.debug('LG | Using shallow redis as checkpoint');
-            const { ShallowRedisSaver } = await import('@langchain/langgraph-checkpoint-redis/shallow');
-            return await ShallowRedisSaver.fromUrl(process.env.REDIS_URL);
-        }
-    }
-    if (process.env.DATABASE_URL) {
-        console.debug('LG | Using postgres as checkpoint');
-        const { createPGCheckpoint } = await import('./pg/checkpoint');
-        return createPGCheckpoint();
-    }
-    if (process.env.SQLITE_DATABASE_URI) {
-        console.debug('LG | Using sqlite as checkpoint');
-        const { SqliteSaver } = await import('./sqlite/checkpoint');
-        const db = SqliteSaver.fromConnString(process.env.SQLITE_DATABASE_URI);
-        return db;
-    }
-    return new MemorySaver();
-};
-export const createMessageQueue = async () => {
-    let q;
-    if (process.env.REDIS_URL) {
-        console.debug('LG | Using redis as stream queue');
-        const { RedisStreamQueue } = await import('./redis/queue');
-        q = RedisStreamQueue;
-    }
-    else {
-        q = MemoryStreamQueue;
-    }
-    return new StreamQueueManager(q);
-};
-export const createThreadManager = async (config) => {
-    if (process.env.DATABASE_URL && config.checkpointer) {
-        const { PostgresThreadsManager } = await import('./pg/threads');
-        const threadsManager = new PostgresThreadsManager(config.checkpointer);
-        if (process.env.DATABASE_INIT === 'true') {
-            await threadsManager.setup();
-        }
-        return threadsManager;
-    }
-    if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
-        const threadsManager = new SQLiteThreadsManager(config.checkpointer);
-        await threadsManager.setup();
-        return threadsManager;
-    }
-    return new MemoryThreadsManager();
-};

package/dist/storage/memory/checkpoint.js

@@ -1,2 +0,0 @@
-import { MemorySaver } from '@langchain/langgraph-checkpoint';
-export { MemorySaver };

package/dist/storage/memory/queue.js

@@ -1,81 +0,0 @@
-import { CancelEventMessage } from '../../queue/event_message.js';
-import { BaseStreamQueue } from '../../queue/stream_queue.js';
-/** 内存实现的消息队列，用于存储消息 */
-export class MemoryStreamQueue extends BaseStreamQueue {
-    data = [];
-    async push(item) {
-        const data = this.compressMessages ? (await this.encodeData(item)) : item;
-        this.data.push(data);
-        this.emit('dataChange', data);
-    }
-    onDataChange(listener) {
-        this.on('dataChange', async (item) => {
-            listener(this.compressMessages ? (await this.decodeData(item)) : item);
-        });
-        return () => this.off('dataChange', listener);
-    }
-    /**
-     * 异步生成器：支持 for await...of 方式消费队列数据
-     */
-    async *onDataReceive() {
-        let queue = [];
-        let pendingResolve = null;
-        let isStreamEnded = false;
-        const handleData = async (item) => {
-            const data = this.compressMessages ? (await this.decodeData(item)) : item;
-            queue.push(data);
-            // 检查是否为流结束或错误信号
-            if (data.event === '__stream_end__' ||
-                data.event === '__stream_error__' ||
-                data.event === '__stream_cancel__') {
-                setTimeout(() => {
-                    isStreamEnded = true;
-                    if (pendingResolve) {
-                        pendingResolve();
-                        pendingResolve = null;
-                    }
-                }, 300);
-                if (data.event === '__stream_cancel__') {
-                    this.cancel();
-                }
-            }
-            if (pendingResolve) {
-                pendingResolve();
-                pendingResolve = null;
-            }
-        };
-        // todo 这个框架的事件监听的数据返回顺序有误
-        this.on('dataChange', handleData);
-        try {
-            while (!isStreamEnded) {
-                if (queue.length > 0) {
-                    for (const item of queue) {
-                        yield item;
-                    }
-                    queue = [];
-                }
-                else {
-                    await new Promise((resolve) => {
-                        pendingResolve = resolve;
-                    });
-                }
-            }
-        }
-        finally {
-            this.off('dataChange', handleData);
-        }
-    }
-    async getAll() {
-        return this.compressMessages
-            ? (await Promise.all(this.data.map((i) => this.decodeData(i))))
-            : this.data;
-    }
-    clear() {
-        this.data = [];
-    }
-    cancelSignal = new AbortController();
-    cancel() {
-        this.push(new CancelEventMessage());
-        this.cancelSignal.abort('user cancel this run');
-    }
-}

package/dist/storage/memory/threads.js

@@ -1,145 +0,0 @@
-import { getGraph } from '../../utils/getGraph.js';
-import { serialiseAsDict } from '../../graph/stream.js';
-export class MemoryThreadsManager {
-    threads = [];
-    async setup() {
-        return;
-    }
-    async create(payload) {
-        const threadId = payload?.threadId || crypto.randomUUID();
-        if (payload?.ifExists === 'raise' && this.threads.some((t) => t.thread_id === threadId)) {
-            throw new Error(`Thread with ID ${threadId} already exists.`);
-        }
-        const thread = {
-            thread_id: threadId,
-            created_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-            metadata: payload?.metadata || {},
-            status: 'idle',
-            values: null,
-            interrupts: {},
-        };
-        this.threads.push(thread);
-        return thread;
-    }
-    async search(query) {
-        let filteredThreads = [...this.threads];
-        if (query?.status) {
-            filteredThreads = filteredThreads.filter((t) => t.status === query.status);
-        }
-        if (query?.metadata) {
-            for (const key in query.metadata) {
-                if (Object.prototype.hasOwnProperty.call(query.metadata, key)) {
-                    filteredThreads = filteredThreads.filter((t) => t.metadata && t.metadata[key] === query.metadata?.[key]);
-                }
-            }
-        }
-        if (query?.sortBy) {
-            filteredThreads.sort((a, b) => {
-                let aValue;
-                let bValue;
-                switch (query.sortBy) {
-                    case 'created_at':
-                        aValue = new Date(a.created_at).getTime();
-                        bValue = new Date(b.created_at).getTime();
-                        break;
-                    case 'updated_at':
-                        aValue = new Date(a.updated_at).getTime();
-                        bValue = new Date(b.updated_at).getTime();
-                        break;
-                    default:
-                        return 0;
-                }
-                if (query.sortOrder === 'desc') {
-                    return bValue - aValue;
-                }
-                else {
-                    return aValue - bValue;
-                }
-            });
-        }
-        const offset = query?.offset || 0;
-        const limit = query?.limit || filteredThreads.length;
-        return filteredThreads.slice(offset, offset + limit);
-    }
-    async get(threadId) {
-        const thread = this.threads.find((t) => t.thread_id === threadId);
-        if (!thread) {
-            throw new Error(`Thread with ID ${threadId} not found.`);
-        }
-        return thread;
-    }
-    async set(threadId, thread) {
-        const index = this.threads.findIndex((t) => t.thread_id === threadId);
-        if (index === -1) {
-            throw new Error(`Thread with ID ${threadId} not found.`);
-        }
-        this.threads[index] = { ...this.threads[index], ...thread };
-    }
-    async delete(threadId) {
-        const initialLength = this.threads.length;
-        this.threads = this.threads.filter((t) => t.thread_id !== threadId);
-        if (this.threads.length === initialLength) {
-            throw new Error(`Thread with ID ${threadId} not found.`);
-        }
-    }
-    async updateState(threadId, thread) {
-        const index = this.threads.findIndex((t) => t.thread_id === threadId);
-        if (index === -1) {
-            throw new Error(`Thread with ID ${threadId} not found.`);
-        }
-        const targetThread = this.threads[index];
-        if (targetThread.status === 'busy') {
-            throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
-        }
-        this.threads[index] = { ...targetThread, values: thread.values };
-        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;
-    }
-    runs = [];
-    async createRun(threadId, assistantId, payload) {
-        const runId = crypto.randomUUID();
-        const run = {
-            run_id: runId,
-            thread_id: threadId,
-            assistant_id: assistantId,
-            created_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-            status: 'pending',
-            metadata: payload?.metadata ?? {},
-            multitask_strategy: 'reject',
-        };
-        this.runs.push(run);
-        return run;
-    }
-    async listRuns(threadId, options) {
-        let filteredRuns = [...this.runs];
-        if (options?.status) {
-            filteredRuns = filteredRuns.filter((r) => r.status === options.status);
-        }
-        if (options?.limit) {
-            filteredRuns = filteredRuns.slice(options.offset || 0, (options.offset || 0) + options.limit);
-        }
-        return filteredRuns;
-    }
-    async updateRun(runId, run) {
-        const index = this.runs.findIndex((r) => r.run_id === runId);
-        if (index === -1) {
-            throw new Error(`Run with ID ${runId} not found.`);
-        }
-        this.runs[index] = { ...this.runs[index], ...run };
-    }
-}

package/dist/storage/pg/checkpoint.js

@@ -1,9 +0,0 @@
-import { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
-export const createPGCheckpoint = async () => {
-    const checkpointer = PostgresSaver.fromConnString(process.env.DATABASE_URL);
-    if (process.env.DATABASE_INIT === 'true') {
-        console.debug('LG | Initializing postgres checkpoint');
-        await checkpointer.setup();
-    }
-    return checkpointer;
-};

package/dist/storage/pg/threads.js

@@ -1,303 +0,0 @@
-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;
-    }
-    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);
-        }
-    }
-}