@langgraph-js/pure-graph 1.3.0 → 1.4.0

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,183 +0,0 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-import {
-    Command,
-    Config,
-    Metadata,
-    OnConflictBehavior,
-    Run,
-    RunStatus,
-    SortOrder,
-    Thread,
-    ThreadSortBy,
-    ThreadStatus,
-} from '@langgraph-js/sdk';
-import { getGraph } from '../../utils/getGraph.js';
-import { serialiseAsDict } from '../../graph/stream.js';
-
-export class MemoryThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
-    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.`);
-        }
-    }
-    async updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>> {
-        const index = this.threads.findIndex((t) => t.thread_id === threadId) as number;
-        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 as ValuesType };
-        if (!targetThread.metadata?.graph_id) {
-            throw new Error(`Thread with ID ${threadId} has no graph_id.`);
-        }
-        const graphId = targetThread.metadata?.graph_id as string;
-        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)) as ValuesType });
-        return nextConfig;
-    }
-    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');
-    }
-}

package/src/storage/sqlite/DB.ts

@@ -1,16 +0,0 @@
-import { DatabaseType } from './type';
-
-let Database: new (uri: string) => DatabaseType;
-/** @ts-ignore */
-if (globalThis.Bun) {
-    console.log('Using Bun Sqlite, pid:', process.pid);
-    const BunSqlite = await import('bun:sqlite');
-    /** @ts-ignore */
-    Database = BunSqlite.default;
-} else {
-    /** @ts-ignore */
-    const CommonSqlite = await import('better-sqlite3');
-    Database = CommonSqlite.default;
-}
-
-export { Database };