@langgraph-js/pure-graph 1.4.1 → 1.4.4

package/dist/adapter/nextjs/router.js

@@ -1,179 +0,0 @@
-/** @ts-ignore */
-import { NextResponse } from 'next/server';
-import { client } from './endpoint';
-import { AssistantsSearchSchema, AssistantGraphQuerySchema, RunStreamPayloadSchema, RunListQuerySchema, RunCancelQuerySchema, ThreadCreatePayloadSchema, ThreadSearchPayloadSchema, ThreadStateUpdate, } from '../zod';
-import { serialiseAsDict } from '../../graph/stream';
-// Next.js App Router 的 SSE 响应实现
-async function sseResponse(generator) {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-        async start(controller) {
-            try {
-                for await (const { event, data } of generator) {
-                    const line = `event: ${event}\n` + `data: ${serialiseAsDict(data, 0)}\n\n`;
-                    controller.enqueue(encoder.encode(line));
-                }
-            }
-            catch (err) {
-                // ignore
-            }
-            finally {
-                controller.close();
-            }
-        },
-    });
-    return new Response(stream, {
-        headers: {
-            'Content-Type': 'text/event-stream; charset=utf-8',
-            'Cache-Control': 'no-cache, no-transform',
-            Connection: 'keep-alive',
-        },
-    });
-}
-// 统一路由处理器
-export async function GET(req) {
-    const url = new URL(req.url);
-    const pathname = url.pathname;
-    // Assistants routes
-    if (pathname.match(/\/assistants\/[^/]+\/graph$/)) {
-        const match = pathname.match(/\/assistants\/([^/]+)\/graph$/);
-        if (match) {
-            const assistant_id = match[1];
-            const xrayParam = url.searchParams.get('xray') ?? undefined;
-            const queryParams = { xray: xrayParam };
-            const { xray } = AssistantGraphQuerySchema.parse(queryParams);
-            const data = await client.assistants.getGraph(assistant_id, {
-                xray: xray !== undefined ? xray === 'true' : undefined,
-            });
-            return NextResponse.json(data);
-        }
-    }
-    // Threads routes
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})$/);
-        if (match) {
-            const thread_id = match[1];
-            const data = await client.threads.get(thread_id);
-            return NextResponse.json(data);
-        }
-    }
-    // Runs routes
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/runs$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})\/runs$/);
-        if (match) {
-            const thread_id = match[1];
-            const limit = url.searchParams.get('limit') ?? undefined;
-            const offset = url.searchParams.get('offset') ?? undefined;
-            const status = url.searchParams.get('status') ?? undefined;
-            const queryParams = { limit, offset, status };
-            const { limit: parsedLimit, offset: parsedOffset, status: parsedStatus, } = RunListQuerySchema.parse(queryParams);
-            const runs = await client.runs.list(thread_id, {
-                limit: parsedLimit,
-                offset: parsedOffset,
-                status: parsedStatus,
-            });
-            return Response.json(runs);
-        }
-    }
-    return new NextResponse('Not Found', { status: 404 });
-}
-export async function POST(req) {
-    const url = new URL(req.url);
-    const pathname = url.pathname;
-    // Assistants routes
-    if (pathname.endsWith('/assistants/search')) {
-        const body = await req.json();
-        const payload = AssistantsSearchSchema.parse(body);
-        const data = await client.assistants.search({
-            graphId: payload.graph_id,
-            metadata: payload.metadata,
-            limit: payload.limit,
-            offset: payload.offset,
-        });
-        return NextResponse.json(data, {
-            headers: { 'X-Pagination-Total': String(data.length) },
-        });
-    }
-    // Threads routes
-    if (pathname.endsWith('/threads')) {
-        const body = await req.json();
-        const payload = ThreadCreatePayloadSchema.parse(body);
-        const thread = await client.threads.create({
-            thread_id: payload.thread_id,
-            metadata: payload.metadata,
-            if_exists: payload.if_exists ?? undefined,
-        });
-        return NextResponse.json(thread);
-    }
-    if (pathname.endsWith('/threads/search')) {
-        const body = await req.json();
-        const payload = ThreadSearchPayloadSchema.parse(body);
-        const result = await client.threads.search({
-            metadata: payload.metadata,
-            status: payload.status,
-            limit: payload.limit,
-            offset: payload.offset,
-            sortBy: payload.sort_by ?? undefined,
-            sortOrder: payload.sort_order ?? undefined,
-        });
-        return NextResponse.json(result, {
-            headers: { 'X-Pagination-Total': String(result.length) },
-        });
-    }
-    // Threads state update
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/state$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})\/state$/);
-        if (match) {
-            const thread_id = match[1];
-            const body = await req.json();
-            const payload = ThreadStateUpdate.parse(body);
-            const result = await client.threads.updateState(thread_id, payload);
-            return NextResponse.json(result);
-        }
-    }
-    // Runs routes - stream
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/runs\/stream$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})\/runs\/stream$/);
-        if (match) {
-            const thread_id = match[1];
-            const body = await req.json();
-            const payload = RunStreamPayloadSchema.parse(body);
-            const generator = client.runs.stream(thread_id, payload.assistant_id, payload);
-            return sseResponse(generator);
-        }
-    }
-    // Runs routes - cancel
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/runs\/[0-9a-fA-F-]{36}\/cancel$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})\/runs\/([0-9a-fA-F-]{36})\/cancel$/);
-        if (match) {
-            const thread_id = match[1];
-            const run_id = match[2];
-            const waitParam = url.searchParams.get('wait') ?? undefined;
-            const actionParam = url.searchParams.get('action') ?? undefined;
-            const queryParams = {
-                wait: waitParam ? waitParam === 'true' : false,
-                action: actionParam ?? 'interrupt',
-            };
-            const { wait, action } = RunCancelQuerySchema.parse(queryParams);
-            const promise = client.runs.cancel(thread_id, run_id, wait, action);
-            if (wait)
-                await promise;
-            return new Response(null, { status: wait ? 204 : 202 });
-        }
-    }
-    return new NextResponse('Not Found', { status: 404 });
-}
-export async function DELETE(req) {
-    const url = new URL(req.url);
-    const pathname = url.pathname;
-    // Threads routes
-    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}$/)) {
-        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})$/);
-        if (match) {
-            const thread_id = match[1];
-            await client.threads.delete(thread_id);
-            return new NextResponse(null, { status: 204 });
-        }
-    }
-    return new NextResponse('Not Found', { status: 404 });
-}

package/dist/adapter/zod.js

@@ -1,127 +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/dist/createEndpoint.js

@@ -1,77 +0,0 @@
-import { streamState } from './graph/stream.js';
-import { getGraph, GRAPHS } from './utils/getGraph.js';
-import { LangGraphGlobal } from './global.js';
-export { registerGraph } from './utils/getGraph.js';
-export const AssistantEndpoint = {
-    async search(query) {
-        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: '',
-                },
-            ];
-        }
-        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(),
-        }));
-    },
-    async getGraph(assistantId, options) {
-        const config = {};
-        const graph = await getGraph(assistantId, config);
-        const drawable = await graph.getGraphAsync({
-            ...config,
-            xray: options?.xray ?? undefined,
-        });
-        return drawable.toJSON();
-    },
-};
-export const createEndpoint = () => {
-    const threads = LangGraphGlobal.globalThreadsManager;
-    return {
-        assistants: AssistantEndpoint,
-        threads,
-        runs: {
-            list(threadId, options) {
-                return threads.listRuns(threadId, options);
-            },
-            async cancel(threadId, runId, wait, action) {
-                return LangGraphGlobal.globalMessageQueue.cancelQueue(runId);
-            },
-            async *stream(threadId, assistantId, payload) {
-                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, runId, options) {
-                throw new Error('Function not implemented.');
-            },
-        },
-    };
-};

package/dist/global.js

@@ -1,13 +0,0 @@
-import { createCheckPointer, createMessageQueue, createThreadManager } from './storage/index.js';
-const [globalMessageQueue, globalCheckPointer] = await Promise.all([createMessageQueue(), createCheckPointer()]);
-console.debug('LG | checkpointer created');
-const globalThreadsManager = await createThreadManager({
-    checkpointer: globalCheckPointer,
-});
-console.debug('LG | threads manager created');
-console.debug('LG | global init done');
-export class LangGraphGlobal {
-    static globalMessageQueue = globalMessageQueue;
-    static globalCheckPointer = globalCheckPointer;
-    static globalThreadsManager = globalThreadsManager;
-}

package/dist/graph/stream.js

@@ -1,195 +0,0 @@
-import { isBaseMessage } from '@langchain/core/messages';
-import { getLangGraphCommand } from '../utils/getLangGraphCommand.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;
-    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 = 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',
-        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 = {};
-    const completedIds = new Set();
-    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]);
-                // Listen for debug events and capture checkpoint
-                let data = 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 = [];
-                    const [_, chunk] = event.data.chunk;
-                    let chunkMessages = [];
-                    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 = 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) {
-    const queue = LangGraphGlobal.globalMessageQueue.getQueue(queueId);
-    return queue.onDataReceive();
-}
-export const serialiseAsDict = (obj, indent = 2) => {
-    return JSON.stringify(obj, function (key, value) {
-        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, run, payload, options) {
-    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);
-    }
-}