@langgraph-js/pure-graph 1.2.0 → 1.4.0

package/README.md

@@ -1,6 +1,13 @@
 # Pure Graph
 
-Pure Graph is a library that provides a standard LangGraph endpoint for integrating into various frameworks like NextJS and Hono.js. This document will guide you on how to use Pure Graph in your projects.
+Pure Graph is a library that provides a standard LangGraph endpoint for integrating into various frameworks like NextJS and Hono.js. It supports multiple storage backends (SQLite, PostgreSQL, Redis) and message queues. This document will guide you on how to use Pure Graph in your projects.
+
+## Features
+
+-   **Multiple Storage Backends**: Support for SQLite, PostgreSQL, Redis, and in-memory storage
+-   **Message Queue**: Redis-based stream queue with TTL support
+-   **Thread Management**: Comprehensive thread lifecycle management with status tracking
+-   **Framework Integration**: Native support for Next.js and Hono.js frameworks
 
 ## Installation
 
@@ -84,27 +91,28 @@ To integrate Pure Graph into a Hono.js project, follow these steps:
 
 Here are the environment variables you need to configure:
 
-- `SQLITE_DATABASE_URI`: Path to your SQLite database.
-- `CHECKPOINT_TYPE`: Type of checkpoint storage (e.g., `postgres`, `redis`, `shallow/redis`).
-- `REDIS_URL`: URL for Redis (required if using Redis).
+-   `SQLITE_DATABASE_URI`: Path to your SQLite database (e.g., `./.langgraph_api/chat.db`).
+-   `DATABASE_URL`: PostgreSQL connection string (required for PostgreSQL checkpoint storage).
+-   `CHECKPOINT_TYPE`: Type of checkpoint storage (optional, defaults to memory; options: `postgres`, `redis`, `shallow/redis`).
+-   `REDIS_URL`: URL for Redis (required if using Redis checkpoint or message queue).
 
 ## API Endpoints
 
 ### Assistants
 
-- **GET /assistants**: Search for assistants.
-- **GET /assistants/{assistantId}**: Retrieve a specific assistant graph.
+-   **GET /assistants**: Search for assistants.
+-   **GET /assistants/{assistantId}**: Retrieve a specific assistant graph.
 
 ### Threads
 
-- **POST /threads**: Create a new thread.
-- **GET /threads**: Search for threads.
-- **GET /threads/{threadId}**: Retrieve a specific thread.
-- **DELETE /threads/{threadId}**: Delete a specific thread.
+-   **POST /threads**: Create a new thread.
+-   **GET /threads**: Search for threads.
+-   **GET /threads/{threadId}**: Retrieve a specific thread.
+-   **DELETE /threads/{threadId}**: Delete a specific thread.
 
 ### Runs
 
-- **GET /threads/{threadId}/runs**: List runs in a thread.
-- **POST /threads/{threadId}/runs**: Create a new run.
-- **DELETE /threads/{threadId}/runs/{runId}**: Cancel a specific run.
-- **GET /threads/{threadId}/runs/{runId}/stream**: Stream run data.
+-   **GET /threads/{threadId}/runs**: List runs in a thread.
+-   **POST /threads/{threadId}/runs**: Create a new run.
+-   **DELETE /threads/{threadId}/runs/{runId}**: Cancel a specific run.
+-   **GET /threads/{threadId}/runs/{runId}/stream**: Stream run data.

package/dist/adapter/hono/runs.js

@@ -2,8 +2,9 @@ import { zValidator } from '@hono/zod-validator';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { client } from './endpoint';
-import { ThreadIdParamSchema, RunIdParamSchema, RunStreamPayloadSchema, RunListQuerySchema, RunCancelQuerySchema, } from '../zod';
+import { ThreadIdParamSchema, RunIdParamSchema, RunStreamPayloadSchema, RunListQuerySchema, RunCancelQuerySchema, ThreadStateUpdate, } from '../zod';
 import { serialiseAsDict } from '../../graph/stream';
+import z from 'zod';
 const api = new Hono();
 // 最常用的对话接口
 api.post('/threads/:thread_id/runs/stream', zValidator('param', ThreadIdParamSchema), zValidator('json', RunStreamPayloadSchema), async (c) => {
@@ -34,4 +35,20 @@ api.post('/threads/:thread_id/runs/:run_id/cancel', zValidator('param', RunIdPar
     }
     return c.body(null, wait ? 204 : 202);
 });
+api.post('/threads/:thread_id/state', zValidator('param', z.object({ thread_id: z.string().uuid() })), zValidator('json', ThreadStateUpdate), async (c) => {
+    // Update Thread State
+    const { thread_id } = c.req.valid('param');
+    const payload = c.req.valid('json');
+    // const config: RunnableConfig = { configurable: { thread_id } };
+    // if (payload.checkpoint_id) {
+    //     config.configurable ??= {};
+    //     config.configurable.checkpoint_id = payload.checkpoint_id;
+    // }
+    // if (payload.checkpoint) {
+    //     config.configurable ??= {};
+    //     Object.assign(config.configurable, payload.checkpoint);
+    // }
+    const inserted = await client.threads.updateState(thread_id, payload);
+    return c.json(inserted);
+});
 export default api;

package/dist/adapter/nextjs/router.js

@@ -1,7 +1,7 @@
 /** @ts-ignore */
 import { NextResponse } from 'next/server';
 import { client } from './endpoint';
-import { AssistantsSearchSchema, AssistantGraphQuerySchema, RunStreamPayloadSchema, RunListQuerySchema, RunCancelQuerySchema, ThreadCreatePayloadSchema, ThreadSearchPayloadSchema, } from '../zod';
+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) {
@@ -39,7 +39,7 @@ export async function GET(req) {
         const match = pathname.match(/\/assistants\/([^/]+)\/graph$/);
         if (match) {
             const assistant_id = match[1];
-            const xrayParam = url.searchParams.get('xray');
+            const xrayParam = url.searchParams.get('xray') ?? undefined;
             const queryParams = { xray: xrayParam };
             const { xray } = AssistantGraphQuerySchema.parse(queryParams);
             const data = await client.assistants.getGraph(assistant_id, {
@@ -62,9 +62,9 @@ export async function GET(req) {
         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 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, {
@@ -120,6 +120,17 @@ export async function POST(req) {
             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$/);
@@ -137,8 +148,8 @@ export async function POST(req) {
         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 waitParam = url.searchParams.get('wait') ?? undefined;
+            const actionParam = url.searchParams.get('action') ?? undefined;
             const queryParams = {
                 wait: waitParam ? waitParam === 'true' : false,
                 action: actionParam ?? 'interrupt',

package/dist/adapter/zod.d.ts

@@ -101,6 +101,7 @@ export declare const Assistant: z.ZodObject<{
     metadata: {} & {
         [k: string]: any;
     };
+    graph_id: string;
     assistant_id: string;
     config: {
         configurable?: z.objectOutputType<{
@@ -112,13 +113,13 @@ export declare const Assistant: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    graph_id: string;
 }, {
     created_at: string;
     updated_at: string;
     metadata: {} & {
         [k: string]: any;
     };
+    graph_id: string;
     assistant_id: string;
     config: {
         configurable?: z.objectInputType<{
@@ -130,7 +131,6 @@ export declare const Assistant: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    graph_id: string;
 }>;
 export declare const MetadataSchema: z.ZodObject<{
     source: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"input">, z.ZodLiteral<"loop">, z.ZodLiteral<"update">, z.ZodString]>>;
@@ -255,9 +255,9 @@ export declare const AssistantsSearchSchema: z.ZodObject<{
         writes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    graph_id?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    graph_id?: string | undefined;
 }, {
     metadata?: z.objectInputType<{
         source: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"input">, z.ZodLiteral<"loop">, z.ZodLiteral<"update">, z.ZodString]>>;
@@ -265,9 +265,9 @@ export declare const AssistantsSearchSchema: z.ZodObject<{
         writes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    graph_id?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    graph_id?: string | undefined;
 }>;
 export declare const AssistantGraphQuerySchema: z.ZodObject<{
     xray: z.ZodOptional<z.ZodString>;
@@ -395,13 +395,13 @@ export declare const RunStreamPayloadSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     assistant_id: string;
     on_disconnect: "cancel" | "continue";
+    input?: any;
     metadata?: z.objectOutputType<{
         source: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"input">, z.ZodLiteral<"loop">, z.ZodLiteral<"update">, z.ZodString]>>;
         step: z.ZodOptional<z.ZodNumber>;
         writes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.ZodUnknown, "strip"> | undefined;
-    input?: any;
     multitask_strategy?: "reject" | "interrupt" | "rollback" | "enqueue" | undefined;
     checkpoint_id?: string | undefined;
     config?: z.objectOutputType<{
@@ -432,7 +432,7 @@ export declare const RunStreamPayloadSchema: z.ZodObject<{
     webhook?: string | undefined;
     interrupt_before?: string[] | "*" | undefined;
     interrupt_after?: string[] | "*" | undefined;
-    stream_mode?: ("values" | "events" | "messages" | "updates" | "debug" | "custom" | "messages-tuple")[] | undefined;
+    stream_mode?: ("values" | "updates" | "debug" | "messages" | "custom" | "events" | "messages-tuple")[] | undefined;
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     after_seconds?: number | undefined;
@@ -442,13 +442,13 @@ export declare const RunStreamPayloadSchema: z.ZodObject<{
     langsmith_tracer?: unknown;
 }, {
     assistant_id: string;
+    input?: any;
     metadata?: z.objectInputType<{
         source: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"input">, z.ZodLiteral<"loop">, z.ZodLiteral<"update">, z.ZodString]>>;
         step: z.ZodOptional<z.ZodNumber>;
         writes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.ZodUnknown, "strip"> | undefined;
-    input?: any;
     multitask_strategy?: "reject" | "interrupt" | "rollback" | "enqueue" | undefined;
     checkpoint_id?: string | undefined;
     config?: z.objectInputType<{
@@ -480,7 +480,7 @@ export declare const RunStreamPayloadSchema: z.ZodObject<{
     interrupt_before?: string[] | "*" | undefined;
     interrupt_after?: string[] | "*" | undefined;
     on_disconnect?: "cancel" | "continue" | undefined;
-    stream_mode?: ("values" | "events" | "messages" | "updates" | "debug" | "custom" | "messages-tuple")[] | undefined;
+    stream_mode?: ("values" | "updates" | "debug" | "messages" | "custom" | "events" | "messages-tuple")[] | undefined;
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     after_seconds?: number | undefined;
@@ -575,3 +575,10 @@ export declare const ThreadSearchPayloadSchema: z.ZodObject<{
     sort_by?: "thread_id" | "status" | "created_at" | "updated_at" | undefined;
     sort_order?: "asc" | "desc" | undefined;
 }>;
+export declare const ThreadStateUpdate: z.ZodObject<{
+    values: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">]>>>;
+}, "strip", z.ZodTypeAny, {
+    values?: Record<string, unknown> | Record<string, unknown>[] | null | undefined;
+}, {
+    values?: Record<string, unknown> | Record<string, unknown>[] | null | undefined;
+}>;

package/dist/adapter/zod.js

@@ -117,3 +117,11 @@ export const ThreadSearchPayloadSchema = z
     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/global.d.ts

@@ -1,6 +1,7 @@
 import type { SqliteSaver } from './storage/sqlite/checkpoint.js';
+import type { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
 export declare class LangGraphGlobal {
     static globalMessageQueue: import("./queue/stream_queue.js").StreamQueueManager<import("./queue/stream_queue.js").BaseStreamQueueInterface>;
-    static globalCheckPointer: SqliteSaver | import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | import("@langchain/langgraph-checkpoint").MemorySaver;
-    static globalThreadsManager: import("./storage/sqlite/threads.js").SQLiteThreadsManager<unknown> | import("./storage/memory/threads.js").MemoryThreadsManager<unknown>;
+    static globalCheckPointer: import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | PostgresSaver | SqliteSaver | import("@langchain/langgraph-checkpoint").MemorySaver;
+    static globalThreadsManager: import("./storage/pg/threads.js").PostgresThreadsManager<unknown> | import("./storage/sqlite/threads.js").SQLiteThreadsManager<unknown> | import("./storage/memory/threads.js").MemoryThreadsManager<unknown>;
 }

package/dist/storage/index.d.ts

@@ -2,9 +2,10 @@ import { BaseStreamQueueInterface, StreamQueueManager } from '../queue/stream_qu
 import { MemorySaver } from './memory/checkpoint';
 import { MemoryThreadsManager } from './memory/threads';
 import type { SqliteSaver as SqliteSaverType } from './sqlite/checkpoint';
+import type { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
 import { SQLiteThreadsManager } from './sqlite/threads';
-export declare const createCheckPointer: () => Promise<SqliteSaverType | import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | MemorySaver>;
+export declare const createCheckPointer: () => Promise<import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | PostgresSaver | SqliteSaverType | MemorySaver>;
 export declare const createMessageQueue: () => Promise<StreamQueueManager<BaseStreamQueueInterface>>;
 export declare const createThreadManager: (config: {
-    checkpointer?: SqliteSaverType;
-}) => SQLiteThreadsManager<unknown> | MemoryThreadsManager<unknown>;
+    checkpointer?: SqliteSaverType | PostgresSaver;
+}) => Promise<import("./pg/threads").PostgresThreadsManager<unknown> | SQLiteThreadsManager<unknown> | MemoryThreadsManager<unknown>>;

package/dist/storage/index.js

@@ -8,6 +8,7 @@ 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') {
+            console.log('Using redis as checkpoint');
             const { RedisSaver } = await import('@langchain/langgraph-checkpoint-redis');
             return await RedisSaver.fromUrl(process.env.REDIS_URL, {
                 defaultTTL: 60, // TTL in minutes
@@ -15,11 +16,18 @@ export const createCheckPointer = async () => {
             });
         }
         if (process.env.CHECKPOINT_TYPE === 'shallow/redis') {
+            console.log('Using shallow redis as checkpoint');
             const { ShallowRedisSaver } = await import('@langchain/langgraph-checkpoint-redis/shallow');
             return await ShallowRedisSaver.fromUrl(process.env.REDIS_URL);
         }
     }
+    if (process.env.DATABASE_URL) {
+        console.log('Using postgres as checkpoint');
+        const { createPGCheckpoint } = await import('./pg/checkpoint');
+        return createPGCheckpoint();
+    }
     if (process.env.SQLITE_DATABASE_URI) {
+        console.log('Using sqlite as checkpoint');
         const { SqliteSaver } = await import('./sqlite/checkpoint');
         const db = SqliteSaver.fromConnString(process.env.SQLITE_DATABASE_URI);
         return db;
@@ -38,7 +46,11 @@ export const createMessageQueue = async () => {
     }
     return new StreamQueueManager(q);
 };
-export const createThreadManager = (config) => {
+export const createThreadManager = async (config) => {
+    if (process.env.DATABASE_URL && config.checkpointer) {
+        const { PostgresThreadsManager } = await import('./pg/threads');
+        return new PostgresThreadsManager(config.checkpointer);
+    }
     if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
         return new SQLiteThreadsManager(config.checkpointer);
     }

package/dist/storage/memory/threads.d.ts

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

package/dist/storage/memory/threads.js

@@ -1,5 +1,6 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-export class MemoryThreadsManager extends BaseThreadsManager {
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class MemoryThreadsManager {
     threads = [];
     async create(payload) {
         const threadId = payload?.threadId || crypto.randomUUID();
@@ -79,6 +80,32 @@ export class MemoryThreadsManager extends BaseThreadsManager {
             throw new Error(`Thread with ID ${threadId} not found.`);
         }
     }
+    async updateState(threadId, thread) {
+        const index = this.threads.findIndex((t) => t.thread_id === threadId);
+        if (index === -1) {
+            throw new Error(`Thread with ID ${threadId} not found.`);
+        }
+        const targetThread = this.threads[index];
+        if (targetThread.status === 'busy') {
+            throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+        }
+        this.threads[index] = { ...targetThread, values: thread.values };
+        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;
+    }
     runs = [];
     async createRun(threadId, assistantId, payload) {
         const runId = crypto.randomUUID();

package/dist/storage/pg/checkpoint.d.ts

@@ -0,0 +1,2 @@
+import { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
+export declare const createPGCheckpoint: () => Promise<PostgresSaver>;

package/dist/storage/pg/checkpoint.js

@@ -0,0 +1,9 @@
+import { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
+export const createPGCheckpoint = async () => {
+    const checkpointer = PostgresSaver.fromConnString(process.env.DATABASE_URL);
+    if (process.env.DATABASE_INIT === 'true') {
+        console.log('Initializing postgres checkpoint');
+        await checkpointer.setup();
+    }
+    return checkpointer;
+};

package/dist/storage/pg/threads.d.ts

@@ -0,0 +1,43 @@
+import { BaseThreadsManager } from '../../threads/index.js';
+import { Command, Config, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+import type { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
+export declare class PostgresThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
+    private pool;
+    private isSetup;
+    constructor(checkpointer: PostgresSaver);
+    private setup;
+    create(payload?: {
+        metadata?: Metadata;
+        threadId?: string;
+        ifExists?: OnConflictBehavior;
+        graphId?: string;
+        supersteps?: Array<{
+            updates: Array<{
+                values: unknown;
+                command?: Command;
+                asNode: string;
+            }>;
+        }>;
+    }): Promise<Thread<ValuesType>>;
+    search(query?: {
+        metadata?: Metadata;
+        limit?: number;
+        offset?: number;
+        status?: ThreadStatus;
+        sortBy?: ThreadSortBy;
+        sortOrder?: SortOrder;
+    }): Promise<Thread<ValuesType>[]>;
+    get(threadId: string): Promise<Thread<ValuesType>>;
+    set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void>;
+    updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>>;
+    delete(threadId: string): Promise<void>;
+    createRun(threadId: string, assistantId: string, payload?: {
+        metadata?: Metadata;
+    }): Promise<Run>;
+    listRuns(threadId: string, options?: {
+        limit?: number;
+        offset?: number;
+        status?: RunStatus;
+    }): Promise<Run[]>;
+    updateRun(runId: string, run: Partial<Run>): Promise<void>;
+}