@langgraph-js/pure-graph 1.3.0 → 1.4.0

package/src/graph/stringify.ts

@@ -1,219 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-
-// Stringify that can handle circular references.
-// Inlined due to ESM import issues
-// Source: https://www.npmjs.com/package/fast-safe-stringify
-
-var LIMIT_REPLACE_NODE = '[...]';
-var CIRCULAR_REPLACE_NODE = '[Circular]';
-
-var arr = [];
-var replacerStack = [];
-
-function defaultOptions() {
-    return {
-        depthLimit: Number.MAX_SAFE_INTEGER,
-        edgesLimit: Number.MAX_SAFE_INTEGER,
-    };
-}
-
-// Regular stringify
-export function stringify(obj, replacer?, spacer?, options?) {
-    if (typeof options === 'undefined') {
-        options = defaultOptions();
-    }
-
-    decirc(obj, '', 0, [], undefined, 0, options);
-    var res;
-    try {
-        if (replacerStack.length === 0) {
-            res = JSON.stringify(obj, replacer, spacer);
-        } else {
-            res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
-        }
-    } catch (_) {
-        return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]');
-    } finally {
-        while (arr.length !== 0) {
-            var part = arr.pop();
-            if (part.length === 4) {
-                Object.defineProperty(part[0], part[1], part[3]);
-            } else {
-                part[0][part[1]] = part[2];
-            }
-        }
-    }
-    return res;
-}
-
-function setReplace(replace, val, k, parent) {
-    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
-    if (propertyDescriptor.get !== undefined) {
-        if (propertyDescriptor.configurable) {
-            Object.defineProperty(parent, k, { value: replace });
-            arr.push([parent, k, val, propertyDescriptor]);
-        } else {
-            replacerStack.push([val, k, replace]);
-        }
-    } else {
-        parent[k] = replace;
-        arr.push([parent, k, val]);
-    }
-}
-
-function decirc(val, k, edgeIndex, stack, parent, depth, options) {
-    depth += 1;
-    var i;
-    if (typeof val === 'object' && val !== null) {
-        for (i = 0; i < stack.length; i++) {
-            if (stack[i] === val) {
-                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
-                return;
-            }
-        }
-
-        if (typeof options.depthLimit !== 'undefined' && depth > options.depthLimit) {
-            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
-            return;
-        }
-
-        if (typeof options.edgesLimit !== 'undefined' && edgeIndex + 1 > options.edgesLimit) {
-            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
-            return;
-        }
-
-        stack.push(val);
-        // Optimize for Arrays. Big arrays could kill the performance otherwise!
-        if (Array.isArray(val)) {
-            for (i = 0; i < val.length; i++) {
-                decirc(val[i], i, i, stack, val, depth, options);
-            }
-        } else {
-            var keys = Object.keys(val);
-            for (i = 0; i < keys.length; i++) {
-                var key = keys[i];
-                decirc(val[key], key, i, stack, val, depth, options);
-            }
-        }
-        stack.pop();
-    }
-}
-
-// Stable-stringify
-function compareFunction(a, b) {
-    if (a < b) {
-        return -1;
-    }
-    if (a > b) {
-        return 1;
-    }
-    return 0;
-}
-
-function deterministicStringify(obj, replacer, spacer, options) {
-    if (typeof options === 'undefined') {
-        options = defaultOptions();
-    }
-
-    var tmp = deterministicDecirc(obj, '', 0, [], undefined, 0, options) || obj;
-    var res;
-    try {
-        if (replacerStack.length === 0) {
-            res = JSON.stringify(tmp, replacer, spacer);
-        } else {
-            res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
-        }
-    } catch (_) {
-        return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]');
-    } finally {
-        // Ensure that we restore the object as it was.
-        while (arr.length !== 0) {
-            var part = arr.pop();
-            if (part.length === 4) {
-                Object.defineProperty(part[0], part[1], part[3]);
-            } else {
-                part[0][part[1]] = part[2];
-            }
-        }
-    }
-    return res;
-}
-
-function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
-    depth += 1;
-    var i;
-    if (typeof val === 'object' && val !== null) {
-        for (i = 0; i < stack.length; i++) {
-            if (stack[i] === val) {
-                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
-                return;
-            }
-        }
-        try {
-            if (typeof val.toJSON === 'function') {
-                return;
-            }
-        } catch (_) {
-            return;
-        }
-
-        if (typeof options.depthLimit !== 'undefined' && depth > options.depthLimit) {
-            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
-            return;
-        }
-
-        if (typeof options.edgesLimit !== 'undefined' && edgeIndex + 1 > options.edgesLimit) {
-            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
-            return;
-        }
-
-        stack.push(val);
-        // Optimize for Arrays. Big arrays could kill the performance otherwise!
-        if (Array.isArray(val)) {
-            for (i = 0; i < val.length; i++) {
-                deterministicDecirc(val[i], i, i, stack, val, depth, options);
-            }
-        } else {
-            // Create a temporary object in the required way
-            var tmp = {};
-            var keys = Object.keys(val).sort(compareFunction);
-            for (i = 0; i < keys.length; i++) {
-                var key = keys[i];
-                deterministicDecirc(val[key], key, i, stack, val, depth, options);
-                tmp[key] = val[key];
-            }
-            if (typeof parent !== 'undefined') {
-                arr.push([parent, k, val]);
-                parent[k] = tmp;
-            } else {
-                return tmp;
-            }
-        }
-        stack.pop();
-    }
-}
-
-// wraps replacer function to handle values we couldn't replace
-// and mark them as replaced value
-function replaceGetterValues(replacer) {
-    replacer =
-        typeof replacer !== 'undefined'
-            ? replacer
-            : function (k, v) {
-                  return v;
-              };
-    return function (key, val) {
-        if (replacerStack.length > 0) {
-            for (var i = 0; i < replacerStack.length; i++) {
-                var part = replacerStack[i];
-                if (part[1] === key && part[0] === val) {
-                    val = part[2];
-                    replacerStack.splice(i, 1);
-                    break;
-                }
-            }
-        }
-        return replacer.call(this, key, val);
-    };
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './createEndpoint';
-export * from './types';
-export * from './global';
-
-export * from './threads/index';
-export * from './utils/createEntrypointGraph';

package/src/queue/JsonPlusSerializer.ts

@@ -1,143 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable no-instanceof/no-instanceof */
-import { load } from '@langchain/core/load';
-import type { SerializerProtocol } from '@langchain/langgraph-checkpoint';
-import { stringify } from '../graph/stringify.js';
-
-function isLangChainSerializedObject(value: Record<string, unknown>) {
-    return value !== null && value.lc === 1 && value.type === 'constructor' && Array.isArray(value.id);
-}
-
-/**
- * The replacer in stringify does not allow delegation to built-in LangChain
- * serialization methods, and instead immediately calls `.toJSON()` and
- * continues to stringify subfields.
- *
- * We therefore must start from the most nested elements in the input and
- * deserialize upwards rather than top-down.
- */
-async function _reviver(value: any): Promise<any> {
-    if (value && typeof value === 'object') {
-        if (Array.isArray(value)) {
-            const revivedArray = await Promise.all(value.map((item) => _reviver(item)));
-            return revivedArray;
-        } else {
-            const revivedObj: any = {};
-            for (const [k, v] of Object.entries(value)) {
-                revivedObj[k] = await _reviver(v);
-            }
-
-            if (revivedObj.lc === 2 && revivedObj.type === 'undefined') {
-                return undefined;
-            } else if (revivedObj.lc === 2 && revivedObj.type === 'constructor' && Array.isArray(revivedObj.id)) {
-                try {
-                    const constructorName = revivedObj.id[revivedObj.id.length - 1];
-                    let constructor: any;
-
-                    switch (constructorName) {
-                        case 'Set':
-                            constructor = Set;
-                            break;
-                        case 'Map':
-                            constructor = Map;
-                            break;
-                        case 'RegExp':
-                            constructor = RegExp;
-                            break;
-                        case 'Error':
-                            constructor = Error;
-                            break;
-                        default:
-                            return revivedObj;
-                    }
-                    if (revivedObj.method) {
-                        return (constructor as any)[revivedObj.method](...(revivedObj.args || []));
-                    } else {
-                        return new (constructor as any)(...(revivedObj.args || []));
-                    }
-                } catch (error) {
-                    return revivedObj;
-                }
-            } else if (isLangChainSerializedObject(revivedObj)) {
-                return load(JSON.stringify(revivedObj));
-            }
-
-            return revivedObj;
-        }
-    }
-    return value;
-}
-
-function _encodeConstructorArgs(
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    constructor: Function,
-    method?: string,
-    args?: any[],
-    kwargs?: Record<string, any>,
-): object {
-    return {
-        lc: 2,
-        type: 'constructor',
-        id: [constructor.name],
-        method: method ?? null,
-        args: args ?? [],
-        kwargs: kwargs ?? {},
-    };
-}
-
-function _default(obj: any): any {
-    if (obj === undefined) {
-        return {
-            lc: 2,
-            type: 'undefined',
-        };
-    } else if (obj instanceof Set || obj instanceof Map) {
-        return _encodeConstructorArgs(obj.constructor, undefined, [Array.from(obj)]);
-    } else if (obj instanceof RegExp) {
-        return _encodeConstructorArgs(RegExp, undefined, [obj.source, obj.flags]);
-    } else if (obj instanceof Error) {
-        return _encodeConstructorArgs(obj.constructor, undefined, [obj.message]);
-        // TODO: Remove special case
-    } else if (obj?.lg_name === 'Send') {
-        return {
-            node: obj.node,
-            args: obj.args,
-        };
-    } else {
-        return obj;
-    }
-}
-
-export class JsonPlusSerializer implements SerializerProtocol {
-    protected _dumps(obj: any): Uint8Array {
-        const encoder = new TextEncoder();
-        return encoder.encode(
-            stringify(obj, (_: string, value: any) => {
-                return _default(value);
-            }),
-        );
-    }
-
-    async dumpsTyped(obj: any): Promise<[string, Uint8Array]> {
-        if (obj instanceof Uint8Array) {
-            return ['bytes', obj];
-        } else {
-            return ['json', this._dumps(obj)];
-        }
-    }
-
-    protected async _loads(data: string): Promise<any> {
-        const parsed = JSON.parse(data);
-        return _reviver(parsed);
-    }
-
-    async loadsTyped(type: string, data: Uint8Array | string): Promise<any> {
-        if (type === 'bytes') {
-            return typeof data === 'string' ? new TextEncoder().encode(data) : data;
-        } else if (type === 'json') {
-            return this._loads(typeof data === 'string' ? data : new TextDecoder().decode(data));
-        } else {
-            throw new Error(`Unknown serialization type: ${type}`);
-        }
-    }
-}

package/src/queue/event_message.ts

@@ -1,30 +0,0 @@
-export class EventMessage {
-    event: string;
-    data: unknown;
-    id?: string;
-    constructor(event: string, data?: unknown) {
-        this.event = event;
-        this.data = data;
-    }
-}
-
-export class CancelEventMessage extends EventMessage {
-    constructor() {
-        super('__system_cancel__', 'user cancel this run');
-    }
-}
-
-export class StreamEndEventMessage extends EventMessage {
-    constructor() {
-        super('__stream_end__', 'stream end');
-    }
-}
-
-export class StreamErrorEventMessage extends EventMessage {
-    public constructor(error: Error) {
-        super('__stream_error__', {
-            error: error.name,
-            message: error.message,
-        });
-    }
-}

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 };