@langgraph-js/pure-graph 1.0.0

package/dist/queue/stream_queue.d.ts

@@ -0,0 +1,161 @@
+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 declare class BaseStreamQueue extends EventEmitter<StreamQueueEvents<EventMessage>> {
+    readonly compressMessages: boolean;
+    /** 序列化器实例 / Serializer instance */
+    serializer: JsonPlusSerializer;
+    /**
+     * 构造函数
+     * Constructor
+     * @param compressMessages 是否压缩消息 / Whether to compress messages
+     */
+    constructor(compressMessages?: boolean);
+    /**
+     * 编码数据为 Uint8Array
+     * Encode data to Uint8Array
+     * @param message 要编码的消息 / Message to encode
+     * @returns 编码后的 Uint8Array / Encoded Uint8Array
+     */
+    encodeData(message: EventMessage): Promise<Uint8Array>;
+    /**
+     * 解码数据为 EventMessage
+     * Decode data to EventMessage
+     * @param serializedMessage 要解码的消息 / Message to decode
+     * @returns 解码后的 EventMessage / Decoded EventMessage
+     */
+    decodeData(serializedMessage: string | Uint8Array): Promise<EventMessage>;
+}
+/**
+ * 基础流队列接口
+ * Base stream queue interface
+ */
+export interface BaseStreamQueueInterface {
+    /** 是否压缩消息 / 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
+     */
+    onDataChange(listener: (data: EventMessage) => void): () => void;
+    /** 取消信号控制器 / Cancel signal controller */
+    cancelSignal: AbortController;
+    /** 取消操作 / Cancel operation */
+    cancel(): void;
+}
+/**
+ * StreamQueue 管理器，通过 id 管理多个队列实例
+ * StreamQueue manager, manages multiple queue instances by id
+ */
+export declare class StreamQueueManager<Q extends BaseStreamQueueInterface> {
+    /** 存储队列实例的 Map / Map storing queue instances */
+    private queues;
+    /** 默认是否压缩消息 / Default compress messages setting */
+    private defaultCompressMessages;
+    /** 队列构造函数 / Queue constructor */
+    private queueConstructor;
+    /**
+     * 构造函数
+     * Constructor
+     * @param queueConstructor 队列构造函数 / Queue constructor
+     * @param options 配置选项 / Configuration options
+     */
+    constructor(queueConstructor: new (compressMessages: boolean) => Q, options?: {
+        /** 默认是否压缩消息 / Default compress messages setting */
+        defaultCompressMessages?: boolean;
+    });
+    /**
+     * 创建指定 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;
+    /**
+     * 获取或创建指定 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;
+    /**
+     * 取消指定 id 的队列
+     * Cancel queue with specified id
+     * @param id 队列 ID / Queue ID
+     */
+    cancelQueue(id: string): void;
+    /**
+     * 向指定 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
+     */
+    pushToQueue(id: string, item: EventMessage, compressMessages?: boolean): Promise<void>;
+    /**
+     * 获取指定 id 队列中的所有数据
+     * Get all data from queue with specified id
+     * @param id 队列 ID / Queue ID
+     * @returns 队列中的所有数据 / All data in the queue
+     */
+    getQueueData(id: string): Promise<EventMessage[]>;
+    /**
+     * 清空指定 id 的队列
+     * Clear queue with specified id
+     * @param id 队列 ID / Queue ID
+     */
+    clearQueue(id: string): void;
+    /**
+     * 删除指定 id 的队列
+     * Remove queue with specified id
+     * @param id 队列 ID / Queue ID
+     * @returns 是否成功删除 / Whether successfully deleted
+     */
+    removeQueue(id: string): void;
+    /**
+     * 获取所有队列的 ID
+     * Get all queue IDs
+     * @returns 所有队列 ID 的数组 / Array of all queue IDs
+     */
+    getAllQueueIds(): string[];
+    /**
+     * 获取所有队列及其数据的快照
+     * Get snapshot of all queues and their data
+     * @returns 包含所有队列数据的结果对象 / Result object containing all queue data
+     */
+    getAllQueuesData(): Promise<Record<string, EventMessage[]>>;
+    /**
+     * 清空所有队列
+     * Clear all queues
+     */
+    clearAllQueues(): void;
+}
+export {};

package/dist/queue/stream_queue.js

@@ -0,0 +1,175 @@
+import { EventEmitter } from 'eventemitter3';
+import { JsonPlusSerializer } from './JsonPlusSerializer.js';
+/**
+ * 基础流队列类
+ * Base stream queue class
+ */
+export class BaseStreamQueue extends EventEmitter {
+    compressMessages;
+    /** 序列化器实例 / Serializer instance */
+    serializer = new JsonPlusSerializer();
+    /**
+     * 构造函数
+     * Constructor
+     * @param compressMessages 是否压缩消息 / Whether to compress messages
+     */
+    constructor(compressMessages = true) {
+        super();
+        this.compressMessages = compressMessages;
+    }
+    /**
+     * 编码数据为 Uint8Array
+     * Encode data to Uint8Array
+     * @param message 要编码的消息 / Message to encode
+     * @returns 编码后的 Uint8Array / Encoded Uint8Array
+     */
+    async encodeData(message) {
+        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) {
+        const message = (await this.serializer.loadsTyped('json', serializedMessage));
+        return message;
+    }
+}
+/**
+ * StreamQueue 管理器，通过 id 管理多个队列实例
+ * StreamQueue manager, manages multiple queue instances by id
+ */
+export class StreamQueueManager {
+    /** 存储队列实例的 Map / Map storing queue instances */
+    queues = new Map();
+    /** 默认是否压缩消息 / Default compress messages setting */
+    defaultCompressMessages;
+    /** 队列构造函数 / Queue constructor */
+    queueConstructor;
+    /**
+     * 构造函数
+     * Constructor
+     * @param queueConstructor 队列构造函数 / Queue constructor
+     * @param options 配置选项 / Configuration options
+     */
+    constructor(queueConstructor, options = {}) {
+        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, compressMessages) {
+        const compress = compressMessages ?? this.defaultCompressMessages;
+        this.queues.set(id, new this.queueConstructor(compress));
+        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) {
+        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) {
+        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, item, compressMessages) {
+        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) {
+        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) {
+        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) {
+        setTimeout(() => {
+            return this.queues.delete(id);
+        }, 500);
+    }
+    /**
+     * 获取所有队列的 ID
+     * Get all queue IDs
+     * @returns 所有队列 ID 的数组 / Array of all queue IDs
+     */
+    getAllQueueIds() {
+        return Array.from(this.queues.keys());
+    }
+    /**
+     * 获取所有队列及其数据的快照
+     * Get snapshot of all queues and their data
+     * @returns 包含所有队列数据的结果对象 / Result object containing all queue data
+     */
+    async getAllQueuesData() {
+        const result = {};
+        for (const [id, queue] of this.queues) {
+            result[id] = await queue.getAll();
+        }
+        return result;
+    }
+    /**
+     * 清空所有队列
+     * Clear all queues
+     */
+    clearAllQueues() {
+        for (const queue of this.queues.values()) {
+            queue.clear();
+        }
+    }
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+import { StreamQueueManager } from '../queue/stream_queue';
+import { MemorySaver } from './memory/checkpoint';
+import { MemoryStreamQueue } from './memory/queue';
+export declare const createCheckPointer: () => MemorySaver;
+export declare const createMessageQueue: () => StreamQueueManager<MemoryStreamQueue>;

package/dist/storage/index.js

@@ -0,0 +1,11 @@
+import { StreamQueueManager } from '../queue/stream_queue';
+import { MemorySaver } from './memory/checkpoint';
+import { MemoryStreamQueue } from './memory/queue';
+// 所有的适配实现，都请写到这里，通过环境变量进行判断使用哪种方式进行适配
+export const createCheckPointer = () => {
+    return new MemorySaver();
+};
+export const createMessageQueue = () => {
+    const q = MemoryStreamQueue;
+    return new StreamQueueManager(q);
+};

package/dist/storage/memory/checkpoint.d.ts

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

package/dist/storage/memory/checkpoint.js

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

package/dist/storage/memory/queue.d.ts

@@ -0,0 +1,17 @@
+import { EventMessage } from '../../queue/event_message.js';
+import { BaseStreamQueue } from '../../queue/stream_queue.js';
+import { BaseStreamQueueInterface } from '../../queue/stream_queue.js';
+/** 内存实现的消息队列，用于存储消息 */
+export declare class MemoryStreamQueue extends BaseStreamQueue implements BaseStreamQueueInterface {
+    private data;
+    push(item: EventMessage): Promise<void>;
+    onDataChange(listener: (data: EventMessage) => void): () => void;
+    /**
+     * 异步生成器：支持 for await...of 方式消费队列数据
+     */
+    onDataReceive(): AsyncGenerator<EventMessage, void, unknown>;
+    getAll(): Promise<EventMessage[]>;
+    clear(): void;
+    cancelSignal: AbortController;
+    cancel(): void;
+}

package/dist/storage/memory/queue.js

@@ -0,0 +1,72 @@
+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() {
+        const 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__') {
+                isStreamEnded = true;
+                if (data.event === '__stream_cancel__') {
+                    this.cancel();
+                }
+            }
+            if (pendingResolve) {
+                pendingResolve();
+                pendingResolve = null;
+            }
+        };
+        this.on('dataChange', handleData);
+        try {
+            while (!isStreamEnded) {
+                if (queue.length > 0) {
+                    const item = queue.shift();
+                    yield item;
+                }
+                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.d.ts

@@ -0,0 +1,39 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+export declare class MemoryThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+    private threads;
+    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>;
+    runs: Run[];
+    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/memory/threads.js

@@ -0,0 +1,115 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+export class MemoryThreadsManager extends BaseThreadsManager {
+    threads = [];
+    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.`);
+        }
+    }
+    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/threads/index.d.ts

@@ -0,0 +1,36 @@
+import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+export declare class BaseThreadsManager<ValuesType = unknown> {
+    create(payload?: {
+        metadata?: Metadata;
+        threadId?: string;
+        ifExists?: OnConflictBehavior;
+        graphId?: string;
+        supersteps?: Array<{
+            updates: Array<{
+                values: unknown;
+                command?: Command;
+                asNode: string;
+            }>;
+        }>;
+    }): Promise<Thread<ValuesType>>;
+    set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void>;
+    search(query?: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+        status?: ThreadStatus;
+        sortBy?: ThreadSortBy;
+        sortOrder?: SortOrder;
+    }): Promise<Thread<ValuesType>[]>;
+    get(threadId: string): Promise<Thread<ValuesType>>;
+    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/threads/index.js

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