@langgraph-js/pure-graph 1.0.2 → 1.3.0

package/dist/storage/sqlite/threads.js

@@ -0,0 +1,300 @@
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class SQLiteThreadsManager {
+    db;
+    isSetup = false;
+    constructor(checkpointer) {
+        this.db = checkpointer.db;
+        this.setup();
+    }
+    setup() {
+        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) {
+        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_id: threadId,
+            created_at: now,
+            updated_at: now,
+            metadata: payload?.metadata || {},
+            status: 'idle',
+            values: null,
+            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) {
+        let sql = 'SELECT * FROM threads';
+        const whereConditions = [];
+        const params = [];
+        // 构建 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);
+        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,
+            values: row.values ? JSON.parse(row.values) : null,
+            interrupts: JSON.parse(row.interrupts),
+        }));
+    }
+    async get(threadId) {
+        const row = this.db.prepare('SELECT * FROM threads WHERE thread_id = ?').get(threadId);
+        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,
+            values: row.values ? JSON.parse(row.values) : null,
+            interrupts: JSON.parse(row.interrupts),
+        };
+    }
+    async set(threadId, thread) {
+        // 检查线程是否存在
+        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 = [];
+        const values = [];
+        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 updateState(threadId, thread) {
+        // 从数据库查询线程信息
+        const row = this.db.prepare('SELECT * FROM threads WHERE thread_id = ?').get(threadId);
+        if (!row) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const targetThread = {
+            thread_id: row.thread_id,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            metadata: JSON.parse(row.metadata),
+            status: row.status,
+            values: row.values ? JSON.parse(row.values) : null,
+            interrupts: JSON.parse(row.interrupts),
+        };
+        if (targetThread.status === 'busy') {
+            throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+        }
+        if (!targetThread.metadata?.graph_id) {
+            throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+        }
+        const graphId = targetThread.metadata?.graph_id;
+        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)) });
+        return nextConfig;
+    }
+    async delete(threadId) {
+        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, assistantId, payload) {
+        const runId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const metadata = JSON.stringify(payload?.metadata ?? {});
+        const 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, options) {
+        let sql = 'SELECT * FROM runs WHERE thread_id = ?';
+        const params = [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);
+        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,
+            metadata: JSON.parse(row.metadata),
+            multitask_strategy: row.multitask_strategy,
+        }));
+    }
+    async updateRun(runId, run) {
+        // 检查运行是否存在
+        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 = [];
+        const values = [];
+        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/dist/storage/sqlite/type.d.ts

@@ -0,0 +1,15 @@
+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[];
+}
+export {};

package/dist/storage/sqlite/type.js

@@ -0,0 +1 @@
+export {};

package/dist/threads/index.d.ts

@@ -1,5 +1,5 @@
-import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
-export declare class BaseThreadsManager<ValuesType = unknown> {
+import { Command, Config, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+export interface BaseThreadsManager<ValuesType = unknown> {
     create(payload?: {
         metadata?: Metadata;
         threadId?: string;
@@ -24,6 +24,7 @@ export declare class BaseThreadsManager<ValuesType = unknown> {
     }): Promise<Thread<ValuesType>[]>;
     get(threadId: string): Promise<Thread<ValuesType>>;
     delete(threadId: string): Promise<void>;
+    updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>>;
     createRun(threadId: string, assistantId: string, payload?: {
         metadata?: Metadata;
     }): Promise<Run>;

package/dist/threads/index.js

@@ -1,26 +1 @@
-export class BaseThreadsManager {
-    create(payload) {
-        throw new Error('Function not implemented.');
-    }
-    set(threadId, thread) {
-        throw new Error('Function not implemented.');
-    }
-    search(query) {
-        throw new Error('Function not implemented.');
-    }
-    get(threadId) {
-        throw new Error('Function not implemented.');
-    }
-    delete(threadId) {
-        throw new Error('Function not implemented.');
-    }
-    createRun(threadId, assistantId, payload) {
-        throw new Error('Function not implemented.');
-    }
-    listRuns(threadId, options) {
-        throw new Error('Function not implemented.');
-    }
-    updateRun(runId, run) {
-        throw new Error('Function not implemented.');
-    }
-}
+export {};

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Thread, Assistant, Run, StreamMode, Command, Metadata, AssistantGraph, OnConflictBehavior, ThreadStatus, Checkpoint } from '@langchain/langgraph-sdk';
+import { Thread, Assistant, Run, StreamMode, Command, Metadata, AssistantGraph, OnConflictBehavior, ThreadStatus, Checkpoint, Config } from '@langchain/langgraph-sdk';
 import { StreamEvent } from '@langchain/core/tracers/log_stream';
 import { EventMessage } from './queue/event_message';
 import { RunnableConfig } from '@langchain/core/runnables';
@@ -71,6 +71,7 @@ export interface ILangGraphClient<TStateType = unknown> {
         }): Promise<Thread<TStateType>[]>;
         get(threadId: string): Promise<Thread<TStateType>>;
         delete(threadId: string): Promise<void>;
+        updateState(threadId: string, thread: Partial<Thread<TStateType>>): Promise<Pick<Config, 'configurable'>>;
     };
     runs: {
         list(threadId: string, options?: {

package/dist/utils/createEntrypointGraph.d.ts

@@ -0,0 +1,14 @@
+import { AnnotationRoot, Pregel } from '@langchain/langgraph';
+export declare const createEntrypointGraph: <StateType extends AnnotationRoot<any>, ConfigType extends AnnotationRoot<any>>({ stateSchema, config, graph, }: {
+    stateSchema: StateType;
+    config?: ConfigType;
+    graph: Pregel<any, any>;
+}) => import("@langchain/langgraph").CompiledStateGraph<{
+    [x: string]: any;
+}, {
+    [x: string]: any;
+} | {
+    [x: string]: any;
+}, string, any, any, any, {
+    [x: string]: any;
+}>;

package/dist/utils/createEntrypointGraph.js

@@ -0,0 +1,11 @@
+import { StateGraph } from '@langchain/langgraph';
+export const createEntrypointGraph = ({ stateSchema, config, graph, }) => {
+    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/dist/utils/getGraph.js

@@ -1,4 +1,4 @@
-import { globalCheckPointer } from '../global';
+import { LangGraphGlobal } from '../global';
 export const GRAPHS = {};
 export async function registerGraph(graphId, graph) {
     GRAPHS[graphId] = graph;
@@ -8,10 +8,10 @@ export async function getGraph(graphId, config, options) {
         throw new Error(`Graph "${graphId}" not found`);
     const compiled = 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;
     return compiled;

package/examples/nextjs/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

package/examples/nextjs/app/api/langgraph/[...path]/route.ts

@@ -0,0 +1,10 @@
+import {
+    GET,
+    POST,
+    DELETE,
+} from "@langgraph-js/pure-graph/dist/adapter/nextjs/router.js";
+import { registerGraph } from "@langgraph-js/pure-graph";
+import { graph } from "../../../../../../test/graph/index";
+registerGraph("test", graph);
+
+export { GET, POST, DELETE };

package/examples/nextjs/app/globals.css

@@ -0,0 +1,26 @@
+@import "tailwindcss";
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: Arial, Helvetica, sans-serif;
+}

package/examples/nextjs/app/layout.tsx

@@ -0,0 +1,34 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}