@langgraph-js/pure-graph 1.0.2 → 1.3.0

package/dist/adapter/zod.js

@@ -0,0 +1,127 @@
+import z from 'zod';
+export const AssistantConfigurable = z
+    .object({
+    thread_id: z.string().optional(),
+    thread_ts: z.string().optional(),
+})
+    .catchall(z.unknown());
+export const AssistantConfig = z
+    .object({
+    tags: z.array(z.string()).optional(),
+    recursion_limit: z.number().int().optional(),
+    configurable: AssistantConfigurable.optional(),
+})
+    .catchall(z.unknown())
+    .describe('The configuration of an assistant.');
+export const Assistant = z.object({
+    assistant_id: z.string().uuid(),
+    graph_id: z.string(),
+    config: AssistantConfig,
+    created_at: z.string(),
+    updated_at: z.string(),
+    metadata: z.object({}).catchall(z.any()),
+});
+export const MetadataSchema = z
+    .object({
+    source: z.union([z.literal('input'), z.literal('loop'), z.literal('update'), z.string()]).optional(),
+    step: z.number().optional(),
+    writes: z.record(z.unknown()).nullable().optional(),
+    parents: z.record(z.string()).optional(),
+})
+    .catchall(z.unknown());
+export const SendSchema = z.object({
+    node: z.string(),
+    input: z.unknown().nullable(),
+});
+export const CommandSchema = z.object({
+    update: z
+        .union([z.record(z.unknown()), z.array(z.tuple([z.string(), z.unknown()]))])
+        .nullable()
+        .optional(),
+    resume: z.unknown().optional(),
+    goto: z.union([SendSchema, z.array(SendSchema), z.string(), z.array(z.string())]).optional(),
+});
+// 公共的查询参数验证 schema
+export const PaginationQuerySchema = z.object({
+    limit: z.number().int().optional(),
+    offset: z.number().int().optional(),
+});
+export const ThreadIdParamSchema = z.object({
+    thread_id: z.string().uuid(),
+});
+export const RunIdParamSchema = z.object({
+    thread_id: z.string().uuid(),
+    run_id: z.string().uuid(),
+});
+// Assistants 相关的 schema
+export const AssistantsSearchSchema = z.object({
+    graph_id: z.string().optional(),
+    metadata: MetadataSchema.optional(),
+    limit: z.number().int().optional(),
+    offset: z.number().int().optional(),
+});
+export const AssistantGraphQuerySchema = z.object({
+    xray: z.string().optional(),
+});
+// Runs 相关的 schema
+export const RunStreamPayloadSchema = z
+    .object({
+    assistant_id: z.union([z.string().uuid(), z.string()]),
+    checkpoint_id: z.string().optional(),
+    input: z.any().optional(),
+    command: CommandSchema.optional(),
+    metadata: MetadataSchema.optional(),
+    config: AssistantConfig.optional(),
+    webhook: z.string().optional(),
+    interrupt_before: z.union([z.literal('*'), z.array(z.string())]).optional(),
+    interrupt_after: z.union([z.literal('*'), z.array(z.string())]).optional(),
+    on_disconnect: z.enum(['cancel', 'continue']).optional().default('continue'),
+    multitask_strategy: z.enum(['reject', 'rollback', 'interrupt', 'enqueue']).optional(),
+    stream_mode: z
+        .array(z.enum(['values', 'messages', 'messages-tuple', 'updates', 'events', 'debug', 'custom']))
+        .optional(),
+    stream_subgraphs: z.boolean().optional(),
+    stream_resumable: z.boolean().optional(),
+    after_seconds: z.number().optional(),
+    if_not_exists: z.enum(['create', 'reject']).optional(),
+    on_completion: z.enum(['complete', 'continue']).optional(),
+    feedback_keys: z.array(z.string()).optional(),
+    langsmith_tracer: z.unknown().optional(),
+})
+    .describe('Payload for creating a stateful run.');
+export const RunListQuerySchema = z.object({
+    limit: z.coerce.number().int().optional(),
+    offset: z.coerce.number().int().optional(),
+    status: z.enum(['pending', 'running', 'error', 'success', 'timeout', 'interrupted']).optional(),
+});
+export const RunCancelQuerySchema = z.object({
+    wait: z.coerce.boolean().optional().default(false),
+    action: z.enum(['interrupt', 'rollback']).optional().default('interrupt'),
+});
+// Threads 相关的 schema
+export const ThreadCreatePayloadSchema = z
+    .object({
+    thread_id: z.string().uuid().describe('The ID of the thread. If not provided, an ID is generated.').optional(),
+    metadata: MetadataSchema.optional(),
+    if_exists: z.union([z.literal('raise'), z.literal('do_nothing')]).optional(),
+})
+    .describe('Payload for creating a thread.');
+export const ThreadSearchPayloadSchema = z
+    .object({
+    metadata: z.record(z.unknown()).describe('Metadata to search for.').optional(),
+    status: z.enum(['idle', 'busy', 'interrupted', 'error']).describe('Filter by thread status.').optional(),
+    values: z.record(z.unknown()).describe('Filter by thread values.').optional(),
+    limit: z.number().int().gte(1).lte(1000).describe('Maximum number to return.').optional(),
+    offset: z.number().int().gte(0).describe('Offset to start from.').optional(),
+    sort_by: z.enum(['thread_id', 'status', 'created_at', 'updated_at']).describe('Sort by field.').optional(),
+    sort_order: z.enum(['asc', 'desc']).describe('Sort order.').optional(),
+})
+    .describe('Payload for listing threads.');
+export const ThreadStateUpdate = z
+    .object({
+    values: z.union([z.record(z.string(), z.unknown()), z.array(z.record(z.string(), z.unknown()))]).nullish(),
+    // as_node: z.string().optional(),
+    // checkpoint_id: z.string().optional(),
+    // checkpoint: CheckpointSchema.nullish(),
+})
+    .describe('Payload for adding state to a thread.');

package/dist/createEndpoint.d.ts

@@ -1,5 +1,4 @@
-import { BaseThreadsManager } from './threads/index.js';
 import { ILangGraphClient } from './types.js';
 export { registerGraph } from './utils/getGraph.js';
 export declare const AssistantEndpoint: ILangGraphClient['assistants'];
-export declare const createEndpoint: (threads: BaseThreadsManager) => ILangGraphClient;
+export declare const createEndpoint: () => ILangGraphClient;

package/dist/createEndpoint.js

@@ -1,6 +1,6 @@
 import { streamState } from './graph/stream.js';
 import { getGraph, GRAPHS } from './utils/getGraph.js';
-import { globalMessageQueue } from './global.js';
+import { LangGraphGlobal } from './global.js';
 export { registerGraph } from './utils/getGraph.js';
 export const AssistantEndpoint = {
     async search(query) {
@@ -41,7 +41,8 @@ export const AssistantEndpoint = {
         return drawable.toJSON();
     },
 };
-export const createEndpoint = (threads) => {
+export const createEndpoint = () => {
+    const threads = LangGraphGlobal.globalThreadsManager;
     return {
         assistants: AssistantEndpoint,
         threads,
@@ -50,7 +51,7 @@ export const createEndpoint = (threads) => {
                 return threads.listRuns(threadId, options);
             },
             async cancel(threadId, runId, wait, action) {
-                return globalMessageQueue.cancelQueue(runId);
+                return LangGraphGlobal.globalMessageQueue.cancelQueue(runId);
             },
             async *stream(threadId, assistantId, payload) {
                 if (!payload.config) {

package/dist/global.d.ts

@@ -1,4 +1,6 @@
-/** 全局队列管理器 */
-export declare const globalMessageQueue: import("./queue/stream_queue.js").StreamQueueManager<import("./storage/memory/queue.js").MemoryStreamQueue>;
-/** 全局 Checkpointer */
-export declare const globalCheckPointer: import("@langchain/langgraph-checkpoint").MemorySaver;
+import type { SqliteSaver } from './storage/sqlite/checkpoint.js';
+export declare class LangGraphGlobal {
+    static globalMessageQueue: import("./queue/stream_queue.js").StreamQueueManager<import("./queue/stream_queue.js").BaseStreamQueueInterface>;
+    static globalCheckPointer: import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | SqliteSaver | import("@langchain/langgraph-checkpoint").MemorySaver;
+    static globalThreadsManager: import("./storage/sqlite/threads.js").SQLiteThreadsManager<unknown> | import("./storage/memory/threads.js").MemoryThreadsManager<unknown>;
+}

package/dist/global.js

@@ -1,5 +1,10 @@
-import { createCheckPointer, createMessageQueue } from './storage/index.js';
-/** 全局队列管理器 */
-export const globalMessageQueue = createMessageQueue();
-/** 全局 Checkpointer */
-export const globalCheckPointer = createCheckPointer();
+import { createCheckPointer, createMessageQueue, createThreadManager } from './storage/index.js';
+const [globalMessageQueue, globalCheckPointer] = await Promise.all([createMessageQueue(), createCheckPointer()]);
+const globalThreadsManager = await createThreadManager({
+    checkpointer: globalCheckPointer,
+});
+export class LangGraphGlobal {
+    static globalMessageQueue = globalMessageQueue;
+    static globalCheckPointer = globalCheckPointer;
+    static globalThreadsManager = globalThreadsManager;
+}

package/dist/graph/stream.d.ts

@@ -23,7 +23,7 @@ export declare function createStreamFromQueue(queueId: string): AsyncGenerator<{
     event: string;
     data: unknown;
 }>;
-export declare const serialiseAsDict: (obj: unknown) => string;
+export declare const serialiseAsDict: (obj: unknown, indent?: number) => string;
 /**
  * 兼容性函数：保持原有 API，同时使用队列模式
  * @param run 运行配置

package/dist/graph/stream.js

@@ -1,6 +1,6 @@
 import { isBaseMessage } from '@langchain/core/messages';
 import { getLangGraphCommand } from '../utils/getLangGraphCommand.js';
-import { globalMessageQueue } from '../global.js';
+import { LangGraphGlobal } from '../global.js';
 import { EventMessage, StreamErrorEventMessage, StreamEndEventMessage } from '../queue/event_message.js';
 export async function streamStateWithQueue(threads, run, queue, payload, options) {
     const kwargs = payload;
@@ -22,7 +22,11 @@ export async function streamStateWithQueue(threads, run, queue, payload, options
     if (userStreamMode.includes('messages')) {
         libStreamMode.add('values');
     }
-    await queue.push(new EventMessage('metadata', { run_id: run.run_id, attempt: options.attempt, graph_id: graphId }));
+    await queue.push(new EventMessage('metadata', {
+        run_id: run.run_id,
+        attempt: options.attempt,
+        graph_id: graphId,
+    }));
     const metadata = {
         ...payload.config?.metadata,
         run_attempt: options.attempt,
@@ -65,7 +69,9 @@ export async function streamStateWithQueue(threads, run, queue, payload, options
                     }
                 }
                 if (mode === 'values') {
-                    await threads.set(run.thread_id, { values: JSON.parse(serialiseAsDict(data)) });
+                    await threads.set(run.thread_id, {
+                        values: data ? JSON.parse(serialiseAsDict(data)) : '',
+                    });
                 }
             }
             else if (userStreamMode.includes('events')) {
@@ -105,7 +111,9 @@ export async function streamStateWithQueue(threads, run, queue, payload, options
                         continue;
                     if (messages[message.id] == null) {
                         messages[message.id] = message;
-                        await queue.push(new EventMessage('messages/metadata', { [message.id]: { metadata: event.metadata } }));
+                        await queue.push(new EventMessage('messages/metadata', {
+                            [message.id]: { metadata: event.metadata },
+                        }));
                     }
                     else {
                         messages[message.id] = messages[message.id].concat(message);
@@ -127,10 +135,10 @@ export async function streamStateWithQueue(threads, run, queue, payload, options
  * @returns 数据流生成器
  */
 export async function* createStreamFromQueue(queueId) {
-    const queue = globalMessageQueue.getQueue(queueId);
+    const queue = LangGraphGlobal.globalMessageQueue.getQueue(queueId);
     return queue.onDataReceive();
 }
-export const serialiseAsDict = (obj) => {
+export const serialiseAsDict = (obj, indent = 2) => {
     return JSON.stringify(obj, function (key, value) {
         const rawValue = this[key];
         if (rawValue != null &&
@@ -142,7 +150,7 @@ export const serialiseAsDict = (obj) => {
             return { ...data, type };
         }
         return value;
-    }, 2);
+    }, indent);
 };
 /**
  * 兼容性函数：保持原有 API，同时使用队列模式
@@ -159,12 +167,12 @@ export async function* streamState(threads, run, payload, options) {
         // 启动队列推送任务（在后台异步执行）
         await threads.set(threadId, { status: 'busy' });
         await threads.updateRun(run.run_id, { status: 'running' });
-        const queue = globalMessageQueue.createQueue(queueId);
+        const queue = LangGraphGlobal.globalMessageQueue.createQueue(queueId);
         const state = queue.onDataReceive();
         streamStateWithQueue(threads, run, queue, payload, options).catch((error) => {
             console.error('Queue task error:', error);
             // 如果生产者出错，向队列推送错误信号
-            globalMessageQueue.pushToQueue(queueId, new StreamErrorEventMessage(error));
+            LangGraphGlobal.globalMessageQueue.pushToQueue(queueId, new StreamErrorEventMessage(error));
             // TODO 不知道这里需不需要错误处理
         });
         for await (const data of state) {
@@ -182,6 +190,6 @@ export async function* streamState(threads, run, payload, options) {
     finally {
         // 在完成后清理队列
         await threads.set(threadId, { status: 'idle' });
-        globalMessageQueue.removeQueue(queueId);
+        LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
     }
 }

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './createEndpoint';
 export * from './types';
 export * from './global';
 export * from './threads/index';
+export * from './utils/createEntrypointGraph';

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './createEndpoint';
 export * from './types';
 export * from './global';
 export * from './threads/index';
+export * from './utils/createEntrypointGraph';

package/dist/queue/stream_queue.d.ts

@@ -16,6 +16,7 @@ interface StreamQueueEvents<T extends EventMessage> {
  * Base stream queue class
  */
 export declare class BaseStreamQueue extends EventEmitter<StreamQueueEvents<EventMessage>> {
+    readonly id: string;
     readonly compressMessages: boolean;
     /** 序列化器实例 / Serializer instance */
     serializer: JsonPlusSerializer;
@@ -24,7 +25,7 @@ export declare class BaseStreamQueue extends EventEmitter<StreamQueueEvents<Even
      * Constructor
      * @param compressMessages 是否压缩消息 / Whether to compress messages
      */
-    constructor(compressMessages?: boolean);
+    constructor(id: string, compressMessages?: boolean);
     /**
      * 编码数据为 Uint8Array
      * Encode data to Uint8Array
@@ -45,6 +46,7 @@ export declare class BaseStreamQueue extends EventEmitter<StreamQueueEvents<Even
  * Base stream queue interface
  */
 export interface BaseStreamQueueInterface {
+    id: string;
     /** 是否压缩消息 / Whether to compress messages */
     compressMessages: boolean;
     /**
@@ -63,7 +65,7 @@ export interface BaseStreamQueueInterface {
      * @param listener 数据变化监听器 / Data change listener
      * @returns 取消监听函数 / Unsubscribe function
      */
-    onDataChange(listener: (data: EventMessage) => void): () => void;
+    onDataReceive(): AsyncGenerator<EventMessage, void, unknown>;
     /** 取消信号控制器 / Cancel signal controller */
     cancelSignal: AbortController;
     /** 取消操作 / Cancel operation */
@@ -86,7 +88,7 @@ export declare class StreamQueueManager<Q extends BaseStreamQueueInterface> {
      * @param queueConstructor 队列构造函数 / Queue constructor
      * @param options 配置选项 / Configuration options
      */
-    constructor(queueConstructor: new (compressMessages: boolean) => Q, options?: {
+    constructor(queueConstructor: new (id: string) => Q, options?: {
         /** 默认是否压缩消息 / Default compress messages setting */
         defaultCompressMessages?: boolean;
     });

package/dist/queue/stream_queue.js

@@ -5,6 +5,7 @@ import { JsonPlusSerializer } from './JsonPlusSerializer.js';
  * Base stream queue class
  */
 export class BaseStreamQueue extends EventEmitter {
+    id;
     compressMessages;
     /** 序列化器实例 / Serializer instance */
     serializer = new JsonPlusSerializer();
@@ -13,8 +14,9 @@ export class BaseStreamQueue extends EventEmitter {
      * Constructor
      * @param compressMessages 是否压缩消息 / Whether to compress messages
      */
-    constructor(compressMessages = true) {
+    constructor(id, compressMessages = true) {
         super();
+        this.id = id;
         this.compressMessages = compressMessages;
     }
     /**
@@ -68,7 +70,7 @@ export class StreamQueueManager {
      */
     createQueue(id, compressMessages) {
         const compress = compressMessages ?? this.defaultCompressMessages;
-        this.queues.set(id, new this.queueConstructor(compress));
+        this.queues.set(id, new this.queueConstructor(id));
         return this.queues.get(id);
     }
     /**

package/dist/storage/index.d.ts

@@ -1,5 +1,10 @@
-import { StreamQueueManager } from '../queue/stream_queue';
+import { BaseStreamQueueInterface, 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>;
+import { MemoryThreadsManager } from './memory/threads';
+import type { SqliteSaver as SqliteSaverType } from './sqlite/checkpoint';
+import { SQLiteThreadsManager } from './sqlite/threads';
+export declare const createCheckPointer: () => Promise<import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | SqliteSaverType | MemorySaver>;
+export declare const createMessageQueue: () => Promise<StreamQueueManager<BaseStreamQueueInterface>>;
+export declare const createThreadManager: (config: {
+    checkpointer?: SqliteSaverType;
+}) => SQLiteThreadsManager<unknown> | MemoryThreadsManager<unknown>;

package/dist/storage/index.js

@@ -1,11 +1,46 @@
 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 = () => {
+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 = () => {
-    const q = MemoryStreamQueue;
+export const createMessageQueue = async () => {
+    let q;
+    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) => {
+    if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
+        return new SQLiteThreadsManager(config.checkpointer);
+    }
+    return new MemoryThreadsManager();
+};

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

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

package/dist/storage/memory/threads.js

@@ -1,5 +1,6 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-export class MemoryThreadsManager extends BaseThreadsManager {
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class MemoryThreadsManager {
     threads = [];
     async create(payload) {
         const threadId = payload?.threadId || crypto.randomUUID();
@@ -79,6 +80,32 @@ export class MemoryThreadsManager extends BaseThreadsManager {
             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();

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

@@ -0,0 +1,39 @@
+import { EventMessage } from '../../queue/event_message.js';
+import { BaseStreamQueue } from '../../queue/stream_queue.js';
+import { BaseStreamQueueInterface } from '../../queue/stream_queue.js';
+import { RedisClientType } from 'redis';
+/**
+ * Redis 实现的消息队列，用于存储消息
+ */
+export declare class RedisStreamQueue extends BaseStreamQueue implements BaseStreamQueueInterface {
+    readonly id: string;
+    static redis: RedisClientType;
+    static subscriberRedis: RedisClientType;
+    private redis;
+    private subscriberRedis;
+    private queueKey;
+    private channelKey;
+    private isConnected;
+    cancelSignal: AbortController;
+    constructor(id?: string);
+    /**
+     * 推送消息到 Redis 队列
+     */
+    push(item: EventMessage): Promise<void>;
+    /**
+     * 异步生成器：支持 for await...of 方式消费队列数据
+     */
+    onDataReceive(): AsyncGenerator<EventMessage, void, unknown>;
+    /**
+     * 获取队列中的所有数据
+     */
+    getAll(): Promise<EventMessage[]>;
+    /**
+     * 清空队列
+     */
+    clear(): void;
+    /**
+     * 取消操作
+     */
+    cancel(): void;
+}