@langgraph-js/pure-graph 1.0.2 → 1.2.0

package/src/storage/sqlite/threads.ts

@@ -0,0 +1,366 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+import {
+    Command,
+    Metadata,
+    OnConflictBehavior,
+    Run,
+    RunStatus,
+    SortOrder,
+    Thread,
+    ThreadSortBy,
+    ThreadStatus,
+} from '@langgraph-js/sdk';
+import type { SqliteSaver } from './checkpoint.js';
+import type { DatabaseType } from './type.js';
+interface ThreadRow {
+    thread_id: string;
+    created_at: string;
+    updated_at: string;
+    metadata: string;
+    status: string;
+    values: string;
+    interrupts: string;
+}
+
+interface RunRow {
+    run_id: string;
+    thread_id: string;
+    assistant_id: string;
+    created_at: string;
+    updated_at: string;
+    status: string;
+    metadata: string;
+    multitask_strategy: string;
+}
+
+export class SQLiteThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+    db: DatabaseType;
+    private isSetup: boolean = false;
+
+    constructor(checkpointer: SqliteSaver) {
+        super();
+        this.db = checkpointer.db;
+        this.setup();
+    }
+
+    private setup(): void {
+        if (this.isSetup) {
+            return;
+        }
+
+        // 创建 threads 表
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS threads (
+                thread_id TEXT PRIMARY KEY,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                metadata TEXT NOT NULL DEFAULT '{}',
+                status TEXT NOT NULL DEFAULT 'idle',
+                [values] TEXT,
+                interrupts TEXT NOT NULL DEFAULT '{}'
+            )
+        `);
+
+        // 创建 runs 表
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS runs (
+                run_id TEXT PRIMARY KEY,
+                thread_id TEXT NOT NULL,
+                assistant_id TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                metadata TEXT NOT NULL DEFAULT '{}',
+                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
+                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+            )
+        `);
+
+        // 创建索引以提高查询性能
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
+
+        this.isSetup = true;
+    }
+
+    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') {
+            const existingThread = this.db.prepare('SELECT thread_id FROM threads WHERE thread_id = ?').get(threadId);
+            if (existingThread) {
+                throw new Error(`Thread with ID ${threadId} already exists.`);
+            }
+        }
+
+        const now = new Date().toISOString();
+        const metadata = JSON.stringify(payload?.metadata || {});
+        const interrupts = JSON.stringify({});
+
+        const thread: Thread<ValuesType> = {
+            thread_id: threadId,
+            created_at: now,
+            updated_at: now,
+            metadata: payload?.metadata || {},
+            status: 'idle',
+            values: null as unknown as ValuesType,
+            interrupts: {},
+        };
+
+        // 插入到数据库
+        this.db
+            .prepare(
+                `
+            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, [values], interrupts)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `,
+            )
+            .run(threadId, now, now, metadata, 'idle', null, interrupts);
+
+        return thread;
+    }
+
+    async search(query?: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+        status?: ThreadStatus;
+        sortBy?: ThreadSortBy;
+        sortOrder?: SortOrder;
+    }): Promise<Thread<ValuesType>[]> {
+        let sql = 'SELECT * FROM threads';
+        const whereConditions: string[] = [];
+        const params: any[] = [];
+
+        // 构建 WHERE 条件
+        if (query?.status) {
+            whereConditions.push('status = ?');
+            params.push(query.status);
+        }
+
+        if (query?.metadata) {
+            for (const [key, value] of Object.entries(query.metadata)) {
+                whereConditions.push(`json_extract(metadata, '$.${key}') = ?`);
+                params.push(JSON.stringify(value));
+            }
+        }
+
+        if (whereConditions.length > 0) {
+            sql += ' WHERE ' + whereConditions.join(' AND ');
+        }
+
+        // 添加排序
+        if (query?.sortBy) {
+            sql += ` ORDER BY ${query.sortBy}`;
+            if (query.sortOrder === 'desc') {
+                sql += ' DESC';
+            } else {
+                sql += ' ASC';
+            }
+        }
+
+        // 添加分页
+        if (query?.limit) {
+            sql += ` LIMIT ${query.limit}`;
+            if (query?.offset) {
+                sql += ` OFFSET ${query.offset}`;
+            }
+        }
+
+        const rows = this.db.prepare(sql).all(...params) as ThreadRow[];
+
+        return rows.map((row) => ({
+            thread_id: row.thread_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            metadata: JSON.parse(row.metadata),
+            status: row.status as ThreadStatus,
+            values: row.values ? JSON.parse(row.values) : (null as unknown as ValuesType),
+            interrupts: JSON.parse(row.interrupts),
+        }));
+    }
+
+    async get(threadId: string): Promise<Thread<ValuesType>> {
+        const row = this.db.prepare('SELECT * FROM threads WHERE thread_id = ?').get(threadId) as ThreadRow;
+        if (!row) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+
+        return {
+            thread_id: row.thread_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            metadata: JSON.parse(row.metadata),
+            status: row.status as ThreadStatus,
+            values: row.values ? JSON.parse(row.values) : (null as unknown as ValuesType),
+            interrupts: JSON.parse(row.interrupts),
+        };
+    }
+    async set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void> {
+        // 检查线程是否存在
+        const existingThread = this.db.prepare('SELECT thread_id FROM threads WHERE thread_id = ?').get(threadId);
+        if (!existingThread) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+
+        const updateFields: string[] = [];
+        const values: any[] = [];
+
+        if (thread.metadata !== undefined) {
+            updateFields.push('metadata = ?');
+            values.push(JSON.stringify(thread.metadata));
+        }
+
+        if (thread.status !== undefined) {
+            updateFields.push('status = ?');
+            values.push(thread.status);
+        }
+
+        if (thread.values !== undefined) {
+            updateFields.push('[values] = ?');
+            values.push(thread.values ? JSON.stringify(thread.values) : null);
+        }
+
+        if (thread.interrupts !== undefined) {
+            updateFields.push('interrupts = ?');
+            values.push(JSON.stringify(thread.interrupts));
+        }
+
+        // 总是更新 updated_at
+        updateFields.push('updated_at = ?');
+        values.push(new Date().toISOString());
+
+        if (updateFields.length > 0) {
+            values.push(threadId);
+            this.db
+                .prepare(
+                    `
+                UPDATE threads 
+                SET ${updateFields.join(', ')} 
+                WHERE thread_id = ?
+            `,
+                )
+                .run(...values);
+        }
+    }
+    async delete(threadId: string): Promise<void> {
+        const result = this.db.prepare('DELETE FROM threads WHERE thread_id = ?').run(threadId);
+        if (result.changes === 0) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+    }
+    async createRun(threadId: string, assistantId: string, payload?: { metadata?: Metadata }): Promise<Run> {
+        const runId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const metadata = JSON.stringify(payload?.metadata ?? {});
+
+        const run: Run = {
+            run_id: runId,
+            thread_id: threadId,
+            assistant_id: assistantId,
+            created_at: now,
+            updated_at: now,
+            status: 'pending',
+            metadata: payload?.metadata ?? {},
+            multitask_strategy: 'reject',
+        };
+
+        // 插入到数据库
+        this.db
+            .prepare(
+                `
+            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+            )
+            .run(runId, threadId, assistantId, now, now, 'pending', metadata, 'reject');
+
+        return run;
+    }
+    async listRuns(
+        threadId: string,
+        options?: { limit?: number; offset?: number; status?: RunStatus },
+    ): Promise<Run[]> {
+        let sql = 'SELECT * FROM runs WHERE thread_id = ?';
+        const params: any[] = [threadId];
+
+        if (options?.status) {
+            sql += ' AND status = ?';
+            params.push(options.status);
+        }
+
+        sql += ' ORDER BY created_at DESC';
+
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+            if (options?.offset) {
+                sql += ` OFFSET ${options.offset}`;
+            }
+        }
+
+        const rows = this.db.prepare(sql).all(...params) as RunRow[];
+
+        return rows.map((row) => ({
+            run_id: row.run_id,
+            thread_id: row.thread_id,
+            assistant_id: row.assistant_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            status: row.status as RunStatus,
+            metadata: JSON.parse(row.metadata),
+            multitask_strategy: row.multitask_strategy as 'reject',
+        }));
+    }
+    async updateRun(runId: string, run: Partial<Run>): Promise<void> {
+        // 检查运行是否存在
+        const existingRun = this.db.prepare('SELECT run_id FROM runs WHERE run_id = ?').get(runId);
+        if (!existingRun) {
+            throw new Error(`Run with ID ${runId} not found.`);
+        }
+
+        const updateFields: string[] = [];
+        const values: any[] = [];
+
+        if (run.status !== undefined) {
+            updateFields.push('status = ?');
+            values.push(run.status);
+        }
+
+        if (run.metadata !== undefined) {
+            updateFields.push('metadata = ?');
+            values.push(JSON.stringify(run.metadata));
+        }
+
+        if (run.multitask_strategy !== undefined) {
+            updateFields.push('multitask_strategy = ?');
+            values.push(run.multitask_strategy);
+        }
+
+        // 总是更新 updated_at
+        updateFields.push('updated_at = ?');
+        values.push(new Date().toISOString());
+
+        if (updateFields.length > 0) {
+            values.push(runId);
+            this.db
+                .prepare(
+                    `
+                UPDATE runs 
+                SET ${updateFields.join(', ')} 
+                WHERE run_id = ?
+            `,
+                )
+                .run(...values);
+        }
+    }
+}

package/src/storage/sqlite/type.ts

@@ -0,0 +1,12 @@
+export interface DatabaseType {
+    prepare(sql: string): Statement;
+    exec(sql: string): void;
+    close(): void;
+    transaction<T extends any[]>(fn: (...args: T) => void): (...args: T) => void;
+}
+
+interface Statement {
+    run(...params: any[]): { changes: number; lastInsertRowid: number };
+    get(...params: any[]): any;
+    all(...params: any[]): any[];
+}

package/src/utils/createEntrypointGraph.ts

@@ -0,0 +1,20 @@
+import { AnnotationRoot, Pregel, StateGraph } from '@langchain/langgraph';
+
+export const createEntrypointGraph = <StateType extends AnnotationRoot<any>, ConfigType extends AnnotationRoot<any>>({
+    stateSchema,
+    config,
+    graph,
+}: {
+    stateSchema: StateType;
+    config?: ConfigType;
+    graph: Pregel<any, any>;
+}) => {
+    const name = graph.getName();
+    return new StateGraph(stateSchema, config)
+        .addNode(name, (state, config) => graph.invoke(state, config))
+        .addEdge('__start__', name)
+        .addEdge(name, '__end__')
+        .compile({
+            name,
+        });
+};

package/src/utils/getGraph.ts

@@ -5,7 +5,7 @@ import {
     CompiledStateGraph,
     LangGraphRunnableConfig,
 } from '@langchain/langgraph';
-import { globalCheckPointer } from '../global';
+import { LangGraphGlobal } from '../global';
 
 export type CompiledGraphFactory<T extends string> = (config: {
     configurable?: Record<string, unknown>;
@@ -33,9 +33,9 @@ export async function getGraph(
         typeof GRAPHS[graphId] === 'function' ? await GRAPHS[graphId](config ?? { configurable: {} }) : GRAPHS[graphId];
 
     if (typeof options?.checkpointer !== 'undefined') {
-        compiled.checkpointer = options?.checkpointer ?? globalCheckPointer;
+        compiled.checkpointer = options?.checkpointer ?? LangGraphGlobal.globalCheckPointer;
     } else {
-        compiled.checkpointer = globalCheckPointer;
+        compiled.checkpointer = LangGraphGlobal.globalCheckPointer;
     }
 
     compiled.store = options?.store ?? undefined;

package/test/graph/entrypoint.ts

@@ -0,0 +1,21 @@
+import { entrypoint } from '@langchain/langgraph';
+import { createReactAgent, createReactAgentAnnotation } from '@langchain/langgraph/prebuilt';
+import { createState } from '@langgraph-js/pro';
+import { createEntrypointGraph } from '../../src/';
+import { ChatOpenAI } from '@langchain/openai';
+const State = createState(createReactAgentAnnotation()).build({});
+const workflow = entrypoint('test-entrypoint', async (state: typeof State.State) => {
+    const agent = createReactAgent({
+        llm: new ChatOpenAI({
+            model: 'qwen-plus',
+        }),
+        prompt: '你是一个智能助手',
+        tools: [],
+    });
+    return agent.invoke(state);
+});
+
+export const graph = createEntrypointGraph({
+    stateSchema: State,
+    graph: workflow,
+});

package/test/graph/index.ts

@@ -1,21 +1,60 @@
-import { entrypoint, StateGraph } from '@langchain/langgraph';
-import { createReactAgent, createReactAgentAnnotation } from '@langchain/langgraph/prebuilt';
+import { interrupt, StateGraph } from '@langchain/langgraph';
+import { HumanInterrupt } from '@langchain/langgraph/prebuilt';
+import { createReactAgentAnnotation } from '@langchain/langgraph/prebuilt';
 import { createState } from '@langgraph-js/pro';
 const state = createState(createReactAgentAnnotation()).build({});
 export const graph = new StateGraph(state)
     .addNode('agent', async (state) => {
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-        console.log('done');
         return {
             messages: [
                 ...state.messages,
                 {
                     role: 'ai',
-                    content: 'Hello, world!',
+                    content: 'Processing...',
+                },
+            ],
+        };
+    })
+    .addNode('interrupt', async (state) => {
+        // interrupt
+        const response = interrupt([
+            {
+                action_request: {
+                    action: 'test',
+                    args: {
+                        a: 1,
+                    },
+                },
+                config: {
+                    allow_ignore: true,
+                    allow_respond: true,
+                    allow_edit: true,
+                    allow_accept: true,
+                },
+                description: 'Please review the tool call',
+            } as HumanInterrupt,
+        ])[0];
+        return {
+            messages: [
+                ...state.messages,
+                {
+                    role: 'ai',
+                    content: response,
                 },
             ],
         };
     })
     .addEdge('__start__', 'agent')
-    .addEdge('agent', '__end__')
+    .addConditionalEdges(
+        'agent',
+        (state) => {
+            // 条件：如果消息数量大于1，则走interrupt路径
+            return state.messages.length > 1 ? 'interrupt' : '__end__';
+        },
+        {
+            interrupt: 'interrupt',
+            __end__: '__end__',
+        },
+    )
+    .addEdge('interrupt', '__end__')
     .compile();

package/test/hono.ts

@@ -1,8 +1,13 @@
 import { registerGraph } from '../src/createEndpoint';
 import { graph } from './graph/index';
+import { graph as entrypointGraph } from './graph/entrypoint';
+// import { graph as agentGraph } from '../packages/agent-graph/src/index';
 import { Hono } from 'hono';
 import LangGraphApp from '../src/adapter/hono/index';
+
 registerGraph('test', graph);
+// registerGraph('agent-graph', agentGraph);
+registerGraph('test-entrypoint', entrypointGraph);
 
 const app = new Hono();
 app.route('/', LangGraphApp);

package/test/test.ts

@@ -1,10 +0,0 @@
-import { registerGraph } from '../src/createEndpoint';
-import { graph } from '/Users/konghayao/code/ai/code-graph/agents/code/graph';
-import { Hono } from 'hono';
-import LangGraphApp from '../src/adapter/hono/index';
-registerGraph('code', graph);
-
-const app = new Hono();
-app.route('/', LangGraphApp);
-
-export default app;