@langgraph-js/pure-graph 1.2.0 → 1.4.0

package/src/queue/stream_queue.ts

@@ -1,237 +0,0 @@
-import { EventEmitter } from 'eventemitter3';
-import { JsonPlusSerializer } from './JsonPlusSerializer.js';
-import { EventMessage } from './event_message.js';
-
-/**
- * 流队列事件接口
- * Stream queue events interface
- */
-interface StreamQueueEvents<T extends EventMessage> {
-    /** 数据事件：当有新数据时触发 / Data event: triggered when new data arrives */
-    data: (data: T) => void;
-    /** 其他事件 / Other events */
-    [key: string]: ((...args: any[]) => void) | undefined;
-}
-
-/**
- * 基础流队列类
- * Base stream queue class
- */
-export class BaseStreamQueue extends EventEmitter<StreamQueueEvents<EventMessage>> {
-    /** 序列化器实例 / Serializer instance */
-    serializer = new JsonPlusSerializer();
-
-    /**
-     * 构造函数
-     * Constructor
-     * @param compressMessages 是否压缩消息 / Whether to compress messages
-     */
-    constructor(readonly id: string, readonly compressMessages: boolean = true) {
-        super();
-    }
-
-    /**
-     * 编码数据为 Uint8Array
-     * Encode data to Uint8Array
-     * @param message 要编码的消息 / Message to encode
-     * @returns 编码后的 Uint8Array / Encoded Uint8Array
-     */
-    async encodeData(message: EventMessage): Promise<Uint8Array> {
-        const [_, serializedMessage] = await this.serializer.dumpsTyped(message);
-        return serializedMessage;
-    }
-
-    /**
-     * 解码数据为 EventMessage
-     * Decode data to EventMessage
-     * @param serializedMessage 要解码的消息 / Message to decode
-     * @returns 解码后的 EventMessage / Decoded EventMessage
-     */
-    async decodeData(serializedMessage: string | Uint8Array): Promise<EventMessage> {
-        const message = (await this.serializer.loadsTyped('json', serializedMessage)) as EventMessage;
-        return message;
-    }
-}
-
-/**
- * 基础流队列接口
- * Base stream queue interface
- */
-export interface BaseStreamQueueInterface {
-    id: string;
-    /** 是否压缩消息 / Whether to compress messages */
-    compressMessages: boolean;
-    /**
-     * 推送数据项到队列
-     * Push item to queue
-     * @param item 要推送的数据项 / Item to push
-     */
-    push(item: EventMessage): Promise<void>;
-    /** 获取所有数据 / Get all data */
-    getAll(): Promise<EventMessage[]>;
-    /** 清空队列 / Clear queue */
-    clear(): void;
-    /**
-     * 监听数据变化
-     * Listen for data changes
-     * @param listener 数据变化监听器 / Data change listener
-     * @returns 取消监听函数 / Unsubscribe function
-     */
-    onDataReceive(): AsyncGenerator<EventMessage, void, unknown>;
-    /** 取消信号控制器 / Cancel signal controller */
-    cancelSignal: AbortController;
-    /** 取消操作 / Cancel operation */
-    cancel(): void;
-}
-
-/**
- * StreamQueue 管理器，通过 id 管理多个队列实例
- * StreamQueue manager, manages multiple queue instances by id
- */
-export class StreamQueueManager<Q extends BaseStreamQueueInterface> {
-    /** 存储队列实例的 Map / Map storing queue instances */
-    private queues: Map<string, Q> = new Map();
-    /** 默认是否压缩消息 / Default compress messages setting */
-    private defaultCompressMessages: boolean;
-    /** 队列构造函数 / Queue constructor */
-    private queueConstructor: new (queueId: string) => Q;
-
-    /**
-     * 构造函数
-     * Constructor
-     * @param queueConstructor 队列构造函数 / Queue constructor
-     * @param options 配置选项 / Configuration options
-     */
-    constructor(
-        queueConstructor: new (id: string) => Q,
-        options: {
-            /** 默认是否压缩消息 / Default compress messages setting */
-            defaultCompressMessages?: boolean;
-        } = {},
-    ) {
-        this.defaultCompressMessages = options.defaultCompressMessages ?? true;
-        this.queueConstructor = queueConstructor;
-    }
-
-    /**
-     * 创建指定 id 的队列
-     * Create queue with specified id
-     * @param id 队列 ID / Queue ID
-     * @param compressMessages 是否压缩消息 / Whether to compress messages
-     * @returns 创建的队列实例 / Created queue instance
-     */
-    createQueue(id: string, compressMessages?: boolean): Q {
-        const compress = compressMessages ?? this.defaultCompressMessages;
-        this.queues.set(id, new this.queueConstructor(id));
-        return this.queues.get(id)!;
-    }
-
-    /**
-     * 获取或创建指定 id 的队列
-     * Get or create queue with specified id
-     * @param id 队列 ID / Queue ID
-     * @param compressMessages 是否压缩消息，默认为构造函数中的默认值 / Whether to compress messages, defaults to constructor default
-     * @returns StreamQueue 实例 / StreamQueue instance
-     */
-    getQueue(id: string): Q {
-        const queue = this.queues.get(id);
-        if (!queue) {
-            throw new Error(`Queue with id '${id}' does not exist`);
-        }
-        return queue;
-    }
-
-    /**
-     * 取消指定 id 的队列
-     * Cancel queue with specified id
-     * @param id 队列 ID / Queue ID
-     */
-    cancelQueue(id: string): void {
-        const queue = this.queues.get(id);
-        if (queue) {
-            queue.cancel();
-            this.removeQueue(id);
-        }
-    }
-    /**
-     * 向指定 id 的队列推送数据
-     * Push data to queue with specified id
-     * @param id 队列 ID / Queue ID
-     * @param item 要推送的数据项 / Item to push
-     * @param compressMessages 是否压缩消息，默认为构造函数中的默认值 / Whether to compress messages, defaults to constructor default
-     */
-    async pushToQueue(id: string, item: EventMessage, compressMessages?: boolean): Promise<void> {
-        const queue = this.getQueue(id);
-        await queue.push(item);
-    }
-
-    /**
-     * 获取指定 id 队列中的所有数据
-     * Get all data from queue with specified id
-     * @param id 队列 ID / Queue ID
-     * @returns 队列中的所有数据 / All data in the queue
-     */
-    async getQueueData(id: string): Promise<EventMessage[]> {
-        const queue = this.queues.get(id);
-        if (!queue) {
-            throw new Error(`Queue with id '${id}' does not exist`);
-        }
-        return await queue.getAll();
-    }
-
-    /**
-     * 清空指定 id 的队列
-     * Clear queue with specified id
-     * @param id 队列 ID / Queue ID
-     */
-    clearQueue(id: string): void {
-        const queue = this.queues.get(id);
-        if (queue) {
-            queue.clear();
-        }
-    }
-
-    /**
-     * 删除指定 id 的队列
-     * Remove queue with specified id
-     * @param id 队列 ID / Queue ID
-     * @returns 是否成功删除 / Whether successfully deleted
-     */
-    removeQueue(id: string) {
-        setTimeout(() => {
-            return this.queues.delete(id);
-        }, 500);
-    }
-
-    /**
-     * 获取所有队列的 ID
-     * Get all queue IDs
-     * @returns 所有队列 ID 的数组 / Array of all queue IDs
-     */
-    getAllQueueIds(): string[] {
-        return Array.from(this.queues.keys());
-    }
-
-    /**
-     * 获取所有队列及其数据的快照
-     * Get snapshot of all queues and their data
-     * @returns 包含所有队列数据的结果对象 / Result object containing all queue data
-     */
-    async getAllQueuesData(): Promise<Record<string, EventMessage[]>> {
-        const result: Record<string, EventMessage[]> = {};
-        for (const [id, queue] of this.queues) {
-            result[id] = await queue.getAll();
-        }
-        return result;
-    }
-
-    /**
-     * 清空所有队列
-     * Clear all queues
-     */
-    clearAllQueues(): void {
-        for (const queue of this.queues.values()) {
-            queue.clear();
-        }
-    }
-}

package/src/storage/index.ts

@@ -1,52 +0,0 @@
-import { BaseStreamQueueInterface, StreamQueueManager } from '../queue/stream_queue';
-import { MemorySaver } from './memory/checkpoint';
-import { MemoryStreamQueue } from './memory/queue';
-import { MemoryThreadsManager } from './memory/threads';
-import type { SqliteSaver as SqliteSaverType } from './sqlite/checkpoint';
-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') {
-            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') {
-            const { ShallowRedisSaver } = await import('@langchain/langgraph-checkpoint-redis/shallow');
-            return await ShallowRedisSaver.fromUrl(process.env.REDIS_URL!);
-        }
-    }
-    if (process.env.SQLITE_DATABASE_URI) {
-        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: new (id: string) => BaseStreamQueueInterface;
-    if (process.env.REDIS_URL) {
-        console.log('Using redis as stream queue');
-        const { RedisStreamQueue } = await import('./redis/queue');
-        q = RedisStreamQueue;
-    } else {
-        q = MemoryStreamQueue;
-    }
-    return new StreamQueueManager(q);
-};
-
-export const createThreadManager = (config: { checkpointer?: SqliteSaverType }) => {
-    if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
-        return new SQLiteThreadsManager(config.checkpointer);
-    }
-    return new MemoryThreadsManager();
-};

package/src/storage/memory/checkpoint.ts

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

package/src/storage/memory/queue.ts

@@ -1,91 +0,0 @@
-import { CancelEventMessage, EventMessage } from '../../queue/event_message.js';
-import { BaseStreamQueue } from '../../queue/stream_queue.js';
-import { BaseStreamQueueInterface } from '../../queue/stream_queue.js';
-/** 内存实现的消息队列，用于存储消息 */
-export class MemoryStreamQueue extends BaseStreamQueue implements BaseStreamQueueInterface {
-    private data: EventMessage[] = [];
-    async push(item: EventMessage): Promise<void> {
-        const data = this.compressMessages ? ((await this.encodeData(item)) as unknown as EventMessage) : item;
-        this.data.push(data);
-        this.emit('dataChange', data);
-    }
-
-    onDataChange(listener: (data: EventMessage) => void): () => void {
-        this.on('dataChange', async (item) => {
-            listener(this.compressMessages ? ((await this.decodeData(item)) as EventMessage) : item);
-        });
-        return () => this.off('dataChange', listener);
-    }
-
-    /**
-     * 异步生成器：支持 for await...of 方式消费队列数据
-     */
-    async *onDataReceive(): AsyncGenerator<EventMessage, void, unknown> {
-        let queue: EventMessage[] = [];
-        let pendingResolve: (() => void) | null = null;
-        let isStreamEnded = false;
-        const handleData = async (item: EventMessage) => {
-            const data = this.compressMessages ? ((await this.decodeData(item as any)) as EventMessage) : 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 as any);
-
-        try {
-            while (!isStreamEnded) {
-                if (queue.length > 0) {
-                    for (const item of queue) {
-                        yield item;
-                    }
-                    queue = [];
-                } else {
-                    await new Promise((resolve) => {
-                        pendingResolve = resolve as () => void;
-                    });
-                }
-            }
-        } finally {
-            this.off('dataChange', handleData as any);
-        }
-    }
-
-    async getAll(): Promise<EventMessage[]> {
-        return this.compressMessages
-            ? ((await Promise.all(
-                  this.data.map((i) => this.decodeData(i as unknown as string | Uint8Array)),
-              )) as unknown as EventMessage[])
-            : this.data;
-    }
-
-    clear(): void {
-        this.data = [];
-    }
-    public cancelSignal = new AbortController();
-    cancel(): void {
-        this.push(new CancelEventMessage());
-        this.cancelSignal.abort('user cancel this run');
-    }
-}

package/src/storage/memory/threads.ts

@@ -1,154 +0,0 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-import {
-    Command,
-    Metadata,
-    OnConflictBehavior,
-    Run,
-    RunStatus,
-    SortOrder,
-    Thread,
-    ThreadSortBy,
-    ThreadStatus,
-} from '@langgraph-js/sdk';
-
-export class MemoryThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
-    private threads: Thread<ValuesType>[] = [];
-
-    async create(payload?: {
-        metadata?: Metadata;
-        threadId?: string;
-        ifExists?: OnConflictBehavior;
-        graphId?: string;
-        supersteps?: Array<{ updates: Array<{ values: unknown; command?: Command; asNode: string }> }>;
-    }): Promise<Thread<ValuesType>> {
-        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<ValuesType> = {
-            thread_id: threadId,
-            created_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-            metadata: payload?.metadata || {},
-            status: 'idle',
-            values: null as unknown as ValuesType,
-            interrupts: {},
-        };
-        this.threads.push(thread);
-        return thread;
-    }
-
-    async search(query?: {
-        metadata?: Metadata;
-        limit?: number;
-        offset?: number;
-        status?: ThreadStatus;
-        sortBy?: ThreadSortBy;
-        sortOrder?: SortOrder;
-    }): Promise<Thread<ValuesType>[]> {
-        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: any;
-                let bValue: any;
-
-                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: string): Promise<Thread<ValuesType>> {
-        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: string, thread: Partial<Thread<ValuesType>>): Promise<void> {
-        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: string): Promise<void> {
-        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.`);
-        }
-    }
-    runs: Run[] = [];
-    async createRun(threadId: string, assistantId: string, payload?: { metadata?: Metadata }): Promise<Run> {
-        const runId = crypto.randomUUID();
-        const run: 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: string,
-        options?: { limit?: number; offset?: number; status?: RunStatus },
-    ): Promise<Run[]> {
-        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: string, run: Partial<Run>): Promise<void> {
-        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/src/storage/redis/queue.ts

@@ -1,148 +0,0 @@
-import { CancelEventMessage, EventMessage } from '../../queue/event_message.js';
-import { BaseStreamQueue } from '../../queue/stream_queue.js';
-import { BaseStreamQueueInterface } from '../../queue/stream_queue.js';
-import { createClient, RedisClientType } from 'redis';
-
-/**
- * Redis 实现的消息队列，用于存储消息
- */
-export class RedisStreamQueue extends BaseStreamQueue implements BaseStreamQueueInterface {
-    static redis: RedisClientType = createClient({ url: process.env.REDIS_URL! });
-    static subscriberRedis: RedisClientType = createClient({ url: process.env.REDIS_URL! });
-    private redis: RedisClientType;
-    private subscriberRedis: RedisClientType;
-    private queueKey: string;
-    private channelKey: string;
-    private isConnected = false;
-    public cancelSignal: AbortController;
-
-    constructor(readonly id: string = 'default') {
-        super(id, true);
-        this.queueKey = `queue:${this.id}`;
-        this.channelKey = `channel:${this.id}`;
-        this.redis = RedisStreamQueue.redis;
-        this.subscriberRedis = RedisStreamQueue.subscriberRedis;
-        this.cancelSignal = new AbortController();
-
-        // 连接 Redis 客户端
-        this.redis.connect();
-        this.subscriberRedis.connect();
-        this.isConnected = true;
-    }
-
-    /**
-     * 推送消息到 Redis 队列
-     */
-    async push(item: EventMessage): Promise<void> {
-        const data = await this.encodeData(item);
-        const serializedData = Buffer.from(data);
-
-        // 推送到队列
-        await this.redis.lPush(this.queueKey, serializedData);
-
-        // 设置队列 TTL 为 300 秒
-        await this.redis.expire(this.queueKey, 300);
-
-        // 发布到频道通知有新数据
-        await this.redis.publish(this.channelKey, serializedData);
-
-        this.emit('dataChange', data);
-    }
-
-    /**
-     * 异步生成器：支持 for await...of 方式消费队列数据
-     */
-    async *onDataReceive(): AsyncGenerator<EventMessage, void, unknown> {
-        let queue: EventMessage[] = [];
-        let pendingResolve: (() => void) | null = null;
-        let isStreamEnded = false;
-        const handleMessage = async (message: string) => {
-            const data = (await this.decodeData(message)) as EventMessage;
-            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;
-            }
-        };
-
-        // 订阅 Redis 频道
-        await this.subscriberRedis.subscribe(this.channelKey, (message) => {
-            handleMessage(message);
-        });
-
-        try {
-            while (!isStreamEnded) {
-                if (queue.length > 0) {
-                    for (const item of queue) {
-                        yield item;
-                    }
-                    queue = [];
-                } else {
-                    await new Promise((resolve) => {
-                        pendingResolve = resolve as () => void;
-                    });
-                }
-            }
-        } finally {
-            await this.subscriberRedis.unsubscribe(this.channelKey);
-        }
-    }
-
-    /**
-     * 获取队列中的所有数据
-     */
-    async getAll(): Promise<EventMessage[]> {
-        const data = await this.redis.lRange(this.queueKey, 0, -1);
-
-        if (!data || data.length === 0) {
-            return [];
-        }
-
-        if (this.compressMessages) {
-            return (await Promise.all(
-                data.map(async (item: string) => {
-                    const parsed = JSON.parse(item) as EventMessage;
-                    return (await this.decodeData(parsed as any)) as EventMessage;
-                }),
-            )) as EventMessage[];
-        } else {
-            return data.map((item: string) => JSON.parse(item) as EventMessage);
-        }
-    }
-
-    /**
-     * 清空队列
-     */
-    clear(): void {
-        if (this.isConnected) {
-            this.redis.del(this.queueKey);
-        }
-    }
-
-    /**
-     * 取消操作
-     */
-    cancel(): void {
-        this.push(new CancelEventMessage());
-        this.cancelSignal.abort('user cancel this run');
-    }
-}