@langgraph-js/pure-graph 1.0.1 → 1.2.0

package/src/adapter/nextjs/router.ts

@@ -0,0 +1,193 @@
+/** @ts-ignore */
+import { NextRequest, NextResponse } from 'next/server';
+import { client } from './endpoint';
+import {
+    AssistantsSearchSchema,
+    AssistantGraphQuerySchema,
+    RunStreamPayloadSchema,
+    RunListQuerySchema,
+    RunCancelQuerySchema,
+    ThreadCreatePayloadSchema,
+    ThreadSearchPayloadSchema,
+} from '../zod';
+import { serialiseAsDict } from '../../graph/stream';
+
+// Next.js App Router 的 SSE 响应实现
+async function sseResponse(generator: AsyncGenerator<{ event: string; data: unknown }>): Promise<Response> {
+    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: NextRequest) {
+    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');
+            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');
+            const offset = url.searchParams.get('offset');
+            const status = url.searchParams.get('status');
+            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: NextRequest) {
+    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 as any,
+            limit: payload.limit,
+            offset: payload.offset,
+        } as any);
+        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 as any,
+            if_exists: (payload.if_exists as any) ?? 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 as any,
+            status: payload.status as any,
+            limit: payload.limit,
+            offset: payload.offset,
+            sortBy: (payload.sort_by as any) ?? undefined,
+            sortOrder: (payload.sort_order as any) ?? undefined,
+        });
+        return NextResponse.json(result, {
+            headers: { 'X-Pagination-Total': String(result.length) },
+        });
+    }
+
+    // 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 as string, payload as any);
+            return sseResponse(generator as any);
+        }
+    }
+
+    // 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');
+            const actionParam = url.searchParams.get('action');
+            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: NextRequest) {
+    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/src/adapter/{hono → nextjs}/zod.ts

@@ -1,4 +1,4 @@
-import z from 'zod';
+import z from "zod";
 
 export const AssistantConfigurable = z
     .object({
@@ -14,7 +14,7 @@ export const AssistantConfig = z
         configurable: AssistantConfigurable.optional(),
     })
     .catchall(z.unknown())
-    .describe('The configuration of an assistant.');
+    .describe("The configuration of an assistant.");
 
 export const Assistant = z.object({
     assistant_id: z.string().uuid(),
@@ -27,7 +27,14 @@ export const Assistant = z.object({
 
 export const MetadataSchema = z
     .object({
-        source: z.union([z.literal('input'), z.literal('loop'), z.literal('update'), z.string()]).optional(),
+        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(),
@@ -41,9 +48,19 @@ export const SendSchema = z.object({
 
 export const CommandSchema = z.object({
     update: z
-        .union([z.record(z.unknown()), z.array(z.tuple([z.string(), z.unknown()]))])
+        .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(),
+    goto: z
+        .union([
+            SendSchema,
+            z.array(SendSchema),
+            z.string(),
+            z.array(z.string()),
+        ])
+        .optional(),
 });

package/src/adapter/zod.ts

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

package/src/createEndpoint.ts

@@ -2,8 +2,7 @@ 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 { BaseThreadsManager } from './threads/index.js';
-import { globalMessageQueue } from './global.js';
+import { LangGraphGlobal } from './global.js';
 import { AssistantSortBy, CancelAction, ILangGraphClient, RunStatus, SortOrder, StreamInputData } from './types.js';
 export { registerGraph } from './utils/getGraph.js';
 
@@ -57,16 +56,24 @@ export const AssistantEndpoint: ILangGraphClient['assistants'] = {
     },
 };
 
-export const createEndpoint = (threads: BaseThreadsManager): ILangGraphClient => {
+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[]> {
+            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 globalMessageQueue.cancelQueue(runId);
+                return LangGraphGlobal.globalMessageQueue.cancelQueue(runId);
             },
             async *stream(threadId: string, assistantId: string, payload: StreamInputData) {
                 if (!payload.config) {

package/src/e.d.ts

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

package/src/global.ts

@@ -1,6 +1,11 @@
-import { createCheckPointer, createMessageQueue } from './storage/index.js';
-
-/** 全局队列管理器 */
-export const globalMessageQueue = createMessageQueue();
-/** 全局 Checkpointer */
-export const globalCheckPointer = createCheckPointer();
+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

@@ -4,7 +4,7 @@ import type { Pregel } from '@langchain/langgraph/pregel';
 import { getLangGraphCommand } from '../utils/getLangGraphCommand.js';
 import type { BaseStreamQueueInterface } from '../queue/stream_queue.js';
 
-import { globalMessageQueue } from '../global.js';
+import { LangGraphGlobal } from '../global.js';
 import { Run } from '@langgraph-js/sdk';
 import { EventMessage, StreamErrorEventMessage, StreamEndEventMessage } from '../queue/event_message.js';
 
@@ -54,7 +54,13 @@ export async function streamStateWithQueue(
         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,
@@ -107,7 +113,9 @@ export async function streamStateWithQueue(
                     }
                 }
                 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')) {
                 await queue.push(new EventMessage('events', event));
@@ -151,7 +159,9 @@ export async function streamStateWithQueue(
                     if (messages[message.id] == null) {
                         messages[message.id] = message;
                         await queue.push(
-                            new EventMessage('messages/metadata', { [message.id]: { metadata: event.metadata } }),
+                            new EventMessage('messages/metadata', {
+                                [message.id]: { metadata: event.metadata },
+                            }),
                         );
                     } else {
                         messages[message.id] = messages[message.id].concat(message);
@@ -174,11 +184,11 @@ export async function streamStateWithQueue(
  * @returns 数据流生成器
  */
 export async function* createStreamFromQueue(queueId: string): AsyncGenerator<{ event: string; data: unknown }> {
-    const queue = globalMessageQueue.getQueue(queueId);
+    const queue = LangGraphGlobal.globalMessageQueue.getQueue(queueId);
     return queue.onDataReceive();
 }
 
-export const serialiseAsDict = (obj: unknown) => {
+export const serialiseAsDict = (obj: unknown, indent = 2) => {
     return JSON.stringify(
         obj,
         function (key: string | number, value: unknown) {
@@ -196,7 +206,7 @@ export const serialiseAsDict = (obj: unknown) => {
 
             return value;
         },
-        2,
+        indent,
     );
 };
 /**
@@ -227,12 +237,12 @@ export async function* streamState(
         // 启动队列推送任务（在后台异步执行）
         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) {
@@ -248,6 +258,6 @@ export async function* streamState(
     } finally {
         // 在完成后清理队列
         await threads.set(threadId, { status: 'idle' });
-        globalMessageQueue.removeQueue(queueId);
+        LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
     }
 }

package/src/index.ts

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

package/src/queue/stream_queue.ts

@@ -26,7 +26,7 @@ export class BaseStreamQueue extends EventEmitter<StreamQueueEvents<EventMessage
      * Constructor
      * @param compressMessages 是否压缩消息 / Whether to compress messages
      */
-    constructor(readonly compressMessages: boolean = true) {
+    constructor(readonly id: string, readonly compressMessages: boolean = true) {
         super();
     }
 
@@ -58,6 +58,7 @@ export class BaseStreamQueue extends EventEmitter<StreamQueueEvents<EventMessage
  * Base stream queue interface
  */
 export interface BaseStreamQueueInterface {
+    id: string;
     /** 是否压缩消息 / Whether to compress messages */
     compressMessages: boolean;
     /**
@@ -76,7 +77,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 */
@@ -93,7 +94,7 @@ export class StreamQueueManager<Q extends BaseStreamQueueInterface> {
     /** 默认是否压缩消息 / Default compress messages setting */
     private defaultCompressMessages: boolean;
     /** 队列构造函数 / Queue constructor */
-    private queueConstructor: new (compressMessages: boolean) => Q;
+    private queueConstructor: new (queueId: string) => Q;
 
     /**
      * 构造函数
@@ -102,7 +103,7 @@ export class StreamQueueManager<Q extends BaseStreamQueueInterface> {
      * @param options 配置选项 / Configuration options
      */
     constructor(
-        queueConstructor: new (compressMessages: boolean) => Q,
+        queueConstructor: new (id: string) => Q,
         options: {
             /** 默认是否压缩消息 / Default compress messages setting */
             defaultCompressMessages?: boolean;
@@ -121,7 +122,7 @@ export class StreamQueueManager<Q extends BaseStreamQueueInterface> {
      */
     createQueue(id: string, compressMessages?: boolean): Q {
         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/src/storage/index.ts

@@ -1,14 +1,52 @@
-import { StreamQueueManager } from '../queue/stream_queue';
+import { BaseStreamQueueInterface, StreamQueueManager } from '../queue/stream_queue';
 import { MemorySaver } from './memory/checkpoint';
 import { MemoryStreamQueue } from './memory/queue';
+import { MemoryThreadsManager } from './memory/threads';
+import type { SqliteSaver as SqliteSaverType } from './sqlite/checkpoint';
+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: new (compressMessages: boolean) => MemoryStreamQueue = MemoryStreamQueue;
+export const createMessageQueue = async () => {
+    let q: new (id: string) => BaseStreamQueueInterface;
+    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: { checkpointer?: SqliteSaverType }) => {
+    if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
+        return new SQLiteThreadsManager(config.checkpointer);
+    }
+    return new MemoryThreadsManager();
+};