@langgraph-js/pure-graph 1.3.0 → 1.4.0

package/src/adapter/zod.ts

@@ -1,144 +0,0 @@
-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/src/createEndpoint.ts

@@ -1,116 +0,0 @@
-import { StreamEvent } from '@langchain/core/tracers/log_stream';
-import { streamState } from './graph/stream.js';
-import { Assistant, Run, StreamMode, Metadata, AssistantGraph } from '@langchain/langgraph-sdk';
-import { getGraph, GRAPHS } from './utils/getGraph.js';
-import { LangGraphGlobal } from './global.js';
-import { AssistantSortBy, CancelAction, ILangGraphClient, RunStatus, SortOrder, StreamInputData } from './types.js';
-export { registerGraph } from './utils/getGraph.js';
-
-export const AssistantEndpoint: ILangGraphClient['assistants'] = {
-    async search(query?: {
-        graphId?: string;
-        metadata?: Metadata;
-        limit?: number;
-        offset?: number;
-        sortBy?: AssistantSortBy;
-        sortOrder?: SortOrder;
-    }): Promise<Assistant[]> {
-        if (query?.graphId) {
-            return [
-                {
-                    assistant_id: query.graphId,
-                    graph_id: query.graphId,
-                    config: {},
-                    created_at: new Date().toISOString(),
-                    updated_at: new Date().toISOString(),
-                    metadata: {},
-                    version: 1,
-                    name: query.graphId,
-                    description: '',
-                } as Assistant,
-            ];
-        }
-        return Object.entries(GRAPHS).map(
-            ([graphId, _]) =>
-                ({
-                    assistant_id: graphId,
-                    graph_id: graphId,
-                    config: {},
-                    metadata: {},
-                    version: 1,
-                    name: graphId,
-                    description: '',
-                    created_at: new Date().toISOString(),
-                    updated_at: new Date().toISOString(),
-                } as Assistant),
-        );
-    },
-    async getGraph(assistantId: string, options?: { xray?: boolean | number }): Promise<AssistantGraph> {
-        const config = {};
-        const graph = await getGraph(assistantId, config);
-        const drawable = await graph.getGraphAsync({
-            ...config,
-            xray: options?.xray ?? undefined,
-        });
-        return drawable.toJSON() as AssistantGraph;
-    },
-};
-
-export const createEndpoint = (): ILangGraphClient => {
-    const threads = LangGraphGlobal.globalThreadsManager;
-    return {
-        assistants: AssistantEndpoint,
-        threads,
-        runs: {
-            list(
-                threadId: string,
-                options?: {
-                    limit?: number;
-                    offset?: number;
-                    status?: RunStatus;
-                },
-            ): Promise<Run[]> {
-                return threads.listRuns(threadId, options);
-            },
-            async cancel(threadId: string, runId: string, wait?: boolean, action?: CancelAction): Promise<void> {
-                return LangGraphGlobal.globalMessageQueue.cancelQueue(runId);
-            },
-            async *stream(threadId: string, assistantId: string, payload: StreamInputData) {
-                if (!payload.config) {
-                    payload.config = {
-                        configurable: {
-                            graph_id: assistantId,
-                            thread_id: threadId,
-                        },
-                    };
-                }
-
-                for await (const data of streamState(
-                    threads,
-                    threads.createRun(threadId, assistantId, payload),
-                    payload,
-                    {
-                        attempt: 0,
-                        getGraph,
-                    },
-                )) {
-                    yield data;
-                }
-            },
-            joinStream(
-                threadId: string,
-                runId: string,
-                options?:
-                    | {
-                          signal?: AbortSignal;
-                          cancelOnDisconnect?: boolean;
-                          lastEventId?: string;
-                          streamMode?: StreamMode | StreamMode[];
-                      }
-                    | AbortSignal,
-            ): AsyncGenerator<{ id?: string; event: StreamEvent; data: any }> {
-                throw new Error('Function not implemented.');
-            },
-        },
-    };
-};

package/src/e.d.ts

@@ -1,3 +0,0 @@
-declare module 'bun:sqlite' {
-    export * from 'better-sqlite3';
-}

package/src/global.ts

@@ -1,11 +0,0 @@
-import { createCheckPointer, createMessageQueue, createThreadManager } from './storage/index.js';
-import type { SqliteSaver } from './storage/sqlite/checkpoint.js';
-const [globalMessageQueue, globalCheckPointer] = await Promise.all([createMessageQueue(), createCheckPointer()]);
-const globalThreadsManager = await createThreadManager({
-    checkpointer: globalCheckPointer as SqliteSaver,
-});
-export class LangGraphGlobal {
-    static globalMessageQueue = globalMessageQueue;
-    static globalCheckPointer = globalCheckPointer;
-    static globalThreadsManager = globalThreadsManager;
-}

package/src/graph/stream.ts

@@ -1,263 +0,0 @@
-import { BaseMessageChunk, isBaseMessage } from '@langchain/core/messages';
-import type { BaseCheckpointSaver, LangGraphRunnableConfig } from '@langchain/langgraph';
-import type { Pregel } from '@langchain/langgraph/pregel';
-import { getLangGraphCommand } from '../utils/getLangGraphCommand.js';
-import type { BaseStreamQueueInterface } from '../queue/stream_queue.js';
-
-import { LangGraphGlobal } from '../global.js';
-import { Run } from '@langgraph-js/sdk';
-import { EventMessage, StreamErrorEventMessage, StreamEndEventMessage } from '../queue/event_message.js';
-
-import { BaseThreadsManager } from '../threads/index.js';
-import { StreamInputData } from '../types.js';
-
-export type LangGraphStreamMode = Pregel<any, any>['streamMode'][number];
-
-export async function streamStateWithQueue(
-    threads: BaseThreadsManager,
-    run: Run,
-    queue: BaseStreamQueueInterface,
-    payload: StreamInputData,
-    options: {
-        attempt: number;
-        getGraph: (
-            graphId: string,
-            config: LangGraphRunnableConfig | undefined,
-            options?: { checkpointer?: BaseCheckpointSaver | null },
-        ) => Promise<Pregel<any, any, any, any, any>>;
-        compressMessages?: boolean;
-    },
-): Promise<void> {
-    const kwargs = payload;
-    const graphId = kwargs.config?.configurable?.graph_id;
-
-    if (!graphId || typeof graphId !== 'string') {
-        throw new Error('Invalid or missing graph_id');
-    }
-
-    const graph = await options.getGraph(graphId, payload.config, {
-        checkpointer: payload.temporary ? null : undefined,
-    });
-
-    const userStreamMode = payload.stream_mode ?? [];
-
-    const libStreamMode: Set<LangGraphStreamMode> = new Set([
-        'values',
-        ...userStreamMode.filter((mode) => mode !== 'events' && mode !== 'messages-tuple'),
-    ]);
-
-    if (userStreamMode.includes('messages-tuple')) {
-        libStreamMode.add('messages');
-    }
-
-    if (userStreamMode.includes('messages')) {
-        libStreamMode.add('values');
-    }
-
-    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,
-    };
-    const events = graph.streamEvents(
-        payload.command != null ? getLangGraphCommand(payload.command) : payload.input ?? null,
-        {
-            version: 'v2' as const,
-
-            interruptAfter: payload.interrupt_after,
-            interruptBefore: payload.interrupt_before,
-
-            tags: payload.config?.tags,
-            configurable: payload.config?.configurable,
-            recursionLimit: payload.config?.recursionLimit,
-            subgraphs: payload.stream_subgraphs,
-            metadata,
-
-            runId: run.run_id,
-            streamMode: [...libStreamMode],
-            signal: queue.cancelSignal.signal,
-        },
-    );
-
-    const messages: Record<string, BaseMessageChunk> = {};
-    const completedIds = new Set<string>();
-
-    try {
-        for await (const event of events) {
-            // console.log(event);
-            if (event.tags?.includes('langsmith:hidden')) continue;
-            if (event.event === 'on_chain_stream' && event.run_id === run.run_id) {
-                const [ns, mode, chunk] = (
-                    payload.stream_subgraphs ? event.data.chunk : [null, ...event.data.chunk]
-                ) as [string[] | null, LangGraphStreamMode, unknown];
-
-                // Listen for debug events and capture checkpoint
-                let data: unknown = chunk;
-
-                if (mode === 'messages') {
-                    if (userStreamMode.includes('messages-tuple')) {
-                        await queue.push(new EventMessage('messages', data));
-                    }
-                } else if (userStreamMode.includes(mode)) {
-                    if (payload.stream_subgraphs && ns?.length) {
-                        await queue.push(new EventMessage(`${mode}|${ns.join('|')}`, data));
-                    } else {
-                        await queue.push(new EventMessage(mode, data));
-                    }
-                }
-                if (mode === 'values') {
-                    await threads.set(run.thread_id, {
-                        values: data ? JSON.parse(serialiseAsDict(data)) : '',
-                    });
-                }
-            } else if (userStreamMode.includes('events')) {
-                await queue.push(new EventMessage('events', event));
-            }
-
-            // TODO: we still rely on old messages mode based of streamMode=values
-            // In order to fully switch to library messages mode, we need to do ensure that
-            // `StreamMessagesHandler` sends the final message, which requires the following:
-            // - handleLLMEnd does not send the final message b/c handleLLMNewToken sets the this.emittedChatModelRunIds[runId] flag. Python does not do that
-            // - handleLLMEnd receives the final message as BaseMessageChunk rather than BaseMessage, which from the outside will become indistinguishable.
-            // - handleLLMEnd should not dedupe the message
-            // - Don't think there's an utility that would convert a BaseMessageChunk to a BaseMessage?
-            if (userStreamMode.includes('messages')) {
-                if (event.event === 'on_chain_stream' && event.run_id === run.run_id) {
-                    const newMessages: Array<BaseMessageChunk> = [];
-                    const [_, chunk]: [string, any] = event.data.chunk;
-
-                    let chunkMessages: Array<BaseMessageChunk> = [];
-                    if (typeof chunk === 'object' && chunk != null && 'messages' in chunk && !isBaseMessage(chunk)) {
-                        chunkMessages = chunk?.messages;
-                    }
-
-                    if (!Array.isArray(chunkMessages)) {
-                        chunkMessages = [chunkMessages];
-                    }
-
-                    for (const message of chunkMessages) {
-                        if (!message.id || completedIds.has(message.id)) continue;
-                        completedIds.add(message.id);
-                        newMessages.push(message);
-                    }
-
-                    if (newMessages.length > 0) {
-                        await queue.push(new EventMessage('messages/complete', newMessages));
-                    }
-                } else if (event.event === 'on_chat_model_stream' && !event.tags?.includes('nostream')) {
-                    const message: BaseMessageChunk = event.data.chunk;
-
-                    if (!message.id) continue;
-
-                    if (messages[message.id] == null) {
-                        messages[message.id] = message;
-                        await queue.push(
-                            new EventMessage('messages/metadata', {
-                                [message.id]: { metadata: event.metadata },
-                            }),
-                        );
-                    } else {
-                        messages[message.id] = messages[message.id].concat(message);
-                    }
-
-                    await queue.push(new EventMessage('messages/partial', [messages[message.id]]));
-                }
-            }
-        }
-    } finally {
-        // 发送流结束信号
-        await queue.push(new StreamEndEventMessage());
-    }
-}
-
-/**
- * 从队列创建数据流生成器
- * @param queueId 队列 ID
- * @param signal 中止信号
- * @returns 数据流生成器
- */
-export async function* createStreamFromQueue(queueId: string): AsyncGenerator<{ event: string; data: unknown }> {
-    const queue = LangGraphGlobal.globalMessageQueue.getQueue(queueId);
-    return queue.onDataReceive();
-}
-
-export const serialiseAsDict = (obj: unknown, indent = 2) => {
-    return JSON.stringify(
-        obj,
-        function (key: string | number, value: unknown) {
-            const rawValue = this[key];
-            if (
-                rawValue != null &&
-                typeof rawValue === 'object' &&
-                'toDict' in rawValue &&
-                typeof rawValue.toDict === 'function'
-            ) {
-                // TODO: we need to upstream this to LangChainJS
-                const { type, data } = rawValue.toDict();
-                return { ...data, type };
-            }
-
-            return value;
-        },
-        indent,
-    );
-};
-/**
- * 兼容性函数：保持原有 API，同时使用队列模式
- * @param run 运行配置
- * @param options 选项
- * @returns 数据流生成器
- */
-export async function* streamState(
-    threads: BaseThreadsManager,
-    run: Run | Promise<Run>,
-    payload: StreamInputData,
-    options: {
-        attempt: number;
-        getGraph: (
-            graphId: string,
-            config: LangGraphRunnableConfig | undefined,
-            options?: { checkpointer?: BaseCheckpointSaver | null },
-        ) => Promise<Pregel<any, any, any, any, any>>;
-        compressMessages?: boolean;
-    },
-) {
-    run = await run;
-    // 生成唯一的队列 ID
-    const queueId = run.run_id;
-    const threadId = run.thread_id;
-    try {
-        // 启动队列推送任务（在后台异步执行）
-        await threads.set(threadId, { status: 'busy' });
-        await threads.updateRun(run.run_id, { status: 'running' });
-        const queue = LangGraphGlobal.globalMessageQueue.createQueue(queueId);
-        const state = queue.onDataReceive();
-        streamStateWithQueue(threads, run, queue, payload, options).catch((error) => {
-            console.error('Queue task error:', error);
-            // 如果生产者出错，向队列推送错误信号
-            LangGraphGlobal.globalMessageQueue.pushToQueue(queueId, new StreamErrorEventMessage(error));
-            // TODO 不知道这里需不需要错误处理
-        });
-        for await (const data of state) {
-            yield data;
-        }
-        await threads.updateRun(run.run_id, { status: 'success' });
-    } catch (error) {
-        // 如果发生错误，确保清理资源
-        console.error('Stream error:', error);
-        await threads.updateRun(run.run_id, { status: 'error' });
-        await threads.set(threadId, { status: 'error' });
-        // throw error;
-    } finally {
-        // 在完成后清理队列
-        await threads.set(threadId, { status: 'idle' });
-        LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
-    }
-}