@langgraph-js/pure-graph 1.2.0 → 1.3.0

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/hono/zod.d.ts

@@ -0,0 +1,203 @@
+import z from 'zod';
+export declare const AssistantConfigurable: z.ZodObject<{
+    thread_id: z.ZodOptional<z.ZodString>;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    thread_id: z.ZodOptional<z.ZodString>;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    thread_id: z.ZodOptional<z.ZodString>;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, z.ZodUnknown, "strip">>;
+export declare const AssistantConfig: z.ZodObject<{
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    recursion_limit: z.ZodOptional<z.ZodNumber>;
+    configurable: z.ZodOptional<z.ZodObject<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">>>;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    recursion_limit: z.ZodOptional<z.ZodNumber>;
+    configurable: z.ZodOptional<z.ZodObject<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">>>;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    recursion_limit: z.ZodOptional<z.ZodNumber>;
+    configurable: z.ZodOptional<z.ZodObject<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        thread_id: z.ZodOptional<z.ZodString>;
+        thread_ts: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">>>;
+}, z.ZodUnknown, "strip">>;
+export declare const Assistant: z.ZodObject<{
+    assistant_id: z.ZodString;
+    graph_id: z.ZodString;
+    config: z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        recursion_limit: z.ZodOptional<z.ZodNumber>;
+        configurable: z.ZodOptional<z.ZodObject<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">>>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        recursion_limit: z.ZodOptional<z.ZodNumber>;
+        configurable: z.ZodOptional<z.ZodObject<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">>>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        recursion_limit: z.ZodOptional<z.ZodNumber>;
+        configurable: z.ZodOptional<z.ZodObject<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip">>>;
+    }, z.ZodUnknown, "strip">>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    metadata: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+}, "strip", z.ZodTypeAny, {
+    created_at: string;
+    updated_at: string;
+    assistant_id: string;
+    graph_id: string;
+    metadata: {} & {
+        [k: string]: any;
+    };
+    config: {
+        configurable?: z.objectOutputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip"> | undefined;
+        tags?: string[] | undefined;
+        recursion_limit?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    created_at: string;
+    updated_at: string;
+    assistant_id: string;
+    graph_id: string;
+    metadata: {} & {
+        [k: string]: any;
+    };
+    config: {
+        configurable?: z.objectInputType<{
+            thread_id: z.ZodOptional<z.ZodString>;
+            thread_ts: z.ZodOptional<z.ZodString>;
+        }, z.ZodUnknown, "strip"> | undefined;
+        tags?: string[] | undefined;
+        recursion_limit?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}>;
+export declare const MetadataSchema: z.ZodObject<{
+    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>>;
+}, "strip", z.ZodUnknown, 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">, 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">>;
+export declare const SendSchema: z.ZodObject<{
+    node: z.ZodString;
+    input: z.ZodNullable<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    node: string;
+    input?: unknown;
+}, {
+    node: string;
+    input?: unknown;
+}>;
+export declare const CommandSchema: z.ZodObject<{
+    update: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnknown], null>, "many">]>>>;
+    resume: z.ZodOptional<z.ZodUnknown>;
+    goto: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        node: z.ZodString;
+        input: z.ZodNullable<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        node: string;
+        input?: unknown;
+    }, {
+        node: string;
+        input?: unknown;
+    }>, z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        input: z.ZodNullable<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        node: string;
+        input?: unknown;
+    }, {
+        node: string;
+        input?: unknown;
+    }>, "many">, z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    update?: Record<string, unknown> | [string, unknown][] | null | undefined;
+    resume?: unknown;
+    goto?: string | string[] | {
+        node: string;
+        input?: unknown;
+    } | {
+        node: string;
+        input?: unknown;
+    }[] | undefined;
+}, {
+    update?: Record<string, unknown> | [string, unknown][] | null | undefined;
+    resume?: unknown;
+    goto?: string | string[] | {
+        node: string;
+        input?: unknown;
+    } | {
+        node: string;
+        input?: unknown;
+    }[] | undefined;
+}>;

package/dist/adapter/hono/zod.js

@@ -0,0 +1,43 @@
+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(),
+});

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) {
@@ -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$/);

package/dist/adapter/nextjs/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]>>;

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,6 @@
 import type { SqliteSaver } from './storage/sqlite/checkpoint.js';
 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 globalCheckPointer: import("@langchain/langgraph-checkpoint-redis").RedisSaver | import("@langchain/langgraph-checkpoint-redis/shallow").ShallowRedisSaver | SqliteSaver | import("@langchain/langgraph-checkpoint").MemorySaver;
     static globalThreadsManager: import("./storage/sqlite/threads.js").SQLiteThreadsManager<unknown> | import("./storage/memory/threads.js").MemoryThreadsManager<unknown>;
 }

package/dist/storage/index.d.ts

@@ -3,7 +3,7 @@ import { MemorySaver } from './memory/checkpoint';
 import { MemoryThreadsManager } from './memory/threads';
 import type { SqliteSaver as SqliteSaverType } from './sqlite/checkpoint';
 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 | SqliteSaverType | MemorySaver>;
 export declare const createMessageQueue: () => Promise<StreamQueueManager<BaseStreamQueueInterface>>;
 export declare const createThreadManager: (config: {
     checkpointer?: SqliteSaverType;

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/sqlite/threads.d.ts

@@ -1,8 +1,8 @@
 import { BaseThreadsManager } from '../../threads/index.js';
-import { Command, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
+import { Command, Config, Metadata, OnConflictBehavior, Run, RunStatus, SortOrder, Thread, ThreadSortBy, ThreadStatus } from '@langgraph-js/sdk';
 import type { SqliteSaver } from './checkpoint.js';
 import type { DatabaseType } from './type.js';
-export declare class SQLiteThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+export declare class SQLiteThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
     db: DatabaseType;
     private isSetup;
     constructor(checkpointer: SqliteSaver);
@@ -30,6 +30,7 @@ export declare class SQLiteThreadsManager<ValuesType = unknown> extends BaseThre
     }): 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;

package/dist/storage/sqlite/threads.js

@@ -1,9 +1,9 @@
-import { BaseThreadsManager } from '../../threads/index.js';
-export class SQLiteThreadsManager extends BaseThreadsManager {
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
+export class SQLiteThreadsManager {
     db;
     isSetup = false;
     constructor(checkpointer) {
-        super();
         this.db = checkpointer.db;
         this.setup();
     }
@@ -174,6 +174,40 @@ export class SQLiteThreadsManager extends BaseThreadsManager {
                 .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) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langgraph-js/pure-graph",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/index.js",
   "keywords": [],
@@ -17,12 +17,12 @@
     "zod": "^3"
   },
   "optionalDependencies": {
+    "@langchain/langgraph-checkpoint-redis": "^0.0.2",
     "@hono/zod-validator": "^0.7.3",
     "hono": "^4.9.9",
     "redis": "^5.8.3"
   },
   "devDependencies": {
-    "@langchain/langgraph-checkpoint-redis": "^0.0.2",
     "@langchain/langgraph-sdk": "^0.1.7",
     "@langchain/openai": "^0.6.14",
     "@langgraph-js/sdk": "^2.0.1",

package/src/adapter/hono/runs.ts

@@ -9,8 +9,11 @@ import {
     RunStreamPayloadSchema,
     RunListQuerySchema,
     RunCancelQuerySchema,
+    ThreadStateUpdate,
 } from '../zod';
 import { serialiseAsDict } from '../../graph/stream';
+import { RunnableConfig } from '@langchain/core/runnables';
+import z from 'zod';
 
 const api = new Hono();
 
@@ -62,4 +65,28 @@ api.post(
     },
 );
 
+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/src/adapter/nextjs/router.ts

@@ -9,6 +9,7 @@ import {
     RunCancelQuerySchema,
     ThreadCreatePayloadSchema,
     ThreadSearchPayloadSchema,
+    ThreadStateUpdate,
 } from '../zod';
 import { serialiseAsDict } from '../../graph/stream';
 
@@ -141,6 +142,18 @@ export async function POST(req: NextRequest) {
         });
     }
 
+    // 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$/);

package/src/adapter/zod.ts

@@ -133,3 +133,12 @@ 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/src/storage/memory/threads.ts

@@ -1,6 +1,7 @@
 import { BaseThreadsManager } from '../../threads/index.js';
 import {
     Command,
+    Config,
     Metadata,
     OnConflictBehavior,
     Run,
@@ -10,8 +11,10 @@ import {
     ThreadSortBy,
     ThreadStatus,
 } from '@langgraph-js/sdk';
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
 
-export class MemoryThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+export class MemoryThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
     private threads: Thread<ValuesType>[] = [];
 
     async create(payload?: {
@@ -115,6 +118,32 @@ export class MemoryThreadsManager<ValuesType = unknown> extends BaseThreadsManag
             throw new Error(`Thread with ID ${threadId} not found.`);
         }
     }
+    async updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>> {
+        const index = this.threads.findIndex((t) => t.thread_id === threadId) as number;
+        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 as ValuesType };
+        if (!targetThread.metadata?.graph_id) {
+            throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+        }
+        const graphId = targetThread.metadata?.graph_id as string;
+        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)) as ValuesType });
+        return nextConfig;
+    }
     runs: Run[] = [];
     async createRun(threadId: string, assistantId: string, payload?: { metadata?: Metadata }): Promise<Run> {
         const runId = crypto.randomUUID();

package/src/storage/sqlite/checkpoint.ts

@@ -296,7 +296,6 @@ CREATE TABLE IF NOT EXISTS writes (
         whereClause.push(
             ...Object.entries(sanitizedFilter).map(([key]) => `jsonb(CAST(metadata AS TEXT))->'$.${key}' = ?`),
         );
-
         if (whereClause.length > 0) {
             sql += `WHERE\n  ${whereClause.join(' AND\n  ')}\n`;
         }

package/src/storage/sqlite/threads.ts

@@ -1,6 +1,7 @@
 import { BaseThreadsManager } from '../../threads/index.js';
 import {
     Command,
+    Config,
     Metadata,
     OnConflictBehavior,
     Run,
@@ -12,6 +13,8 @@ import {
 } from '@langgraph-js/sdk';
 import type { SqliteSaver } from './checkpoint.js';
 import type { DatabaseType } from './type.js';
+import { getGraph } from '../../utils/getGraph.js';
+import { serialiseAsDict } from '../../graph/stream.js';
 interface ThreadRow {
     thread_id: string;
     created_at: string;
@@ -33,12 +36,11 @@ interface RunRow {
     multitask_strategy: string;
 }
 
-export class SQLiteThreadsManager<ValuesType = unknown> extends BaseThreadsManager {
+export class SQLiteThreadsManager<ValuesType = unknown> implements BaseThreadsManager<ValuesType> {
     db: DatabaseType;
     private isSetup: boolean = false;
 
     constructor(checkpointer: SqliteSaver) {
-        super();
         this.db = checkpointer.db;
         this.setup();
     }
@@ -253,6 +255,43 @@ export class SQLiteThreadsManager<ValuesType = unknown> extends BaseThreadsManag
                 .run(...values);
         }
     }
+    async updateState(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<Pick<Config, 'configurable'>> {
+        // 从数据库查询线程信息
+        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.`);
+        }
+
+        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 as ThreadStatus,
+            values: row.values ? JSON.parse(row.values) : (null as unknown as ValuesType),
+            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 as string;
+        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)) as ValuesType });
+        return nextConfig;
+    }
     async delete(threadId: string): Promise<void> {
         const result = this.db.prepare('DELETE FROM threads WHERE thread_id = ?').run(threadId);
         if (result.changes === 0) {

package/src/threads/index.ts

@@ -1,5 +1,6 @@
 import {
     Command,
+    Config,
     Metadata,
     OnConflictBehavior,
     Run,
@@ -10,19 +11,15 @@ import {
     ThreadStatus,
 } from '@langgraph-js/sdk';
 
-export class BaseThreadsManager<ValuesType = unknown> {
+export interface BaseThreadsManager<ValuesType = unknown> {
     create(payload?: {
         metadata?: Metadata;
         threadId?: string;
         ifExists?: OnConflictBehavior;
         graphId?: string;
         supersteps?: Array<{ updates: Array<{ values: unknown; command?: Command; asNode: string }> }>;
-    }): Promise<Thread<ValuesType>> {
-        throw new Error('Function not implemented.');
-    }
-    set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void> {
-        throw new Error('Function not implemented.');
-    }
+    }): Promise<Thread<ValuesType>>;
+    set(threadId: string, thread: Partial<Thread<ValuesType>>): Promise<void>;
     search(query?: {
         metadata?: Metadata;
         limit?: number;
@@ -30,22 +27,11 @@ export class BaseThreadsManager<ValuesType = unknown> {
         status?: ThreadStatus;
         sortBy?: ThreadSortBy;
         sortOrder?: SortOrder;
-    }): Promise<Thread<ValuesType>[]> {
-        throw new Error('Function not implemented.');
-    }
-    get(threadId: string): Promise<Thread<ValuesType>> {
-        throw new Error('Function not implemented.');
-    }
-    delete(threadId: string): Promise<void> {
-        throw new Error('Function not implemented.');
-    }
-    createRun(threadId: string, assistantId: string, payload?: { metadata?: Metadata }): Promise<Run> {
-        throw new Error('Function not implemented.');
-    }
-    listRuns(threadId: string, options?: { limit?: number; offset?: number; status?: RunStatus }): Promise<Run[]> {
-        throw new Error('Function not implemented.');
-    }
-    updateRun(runId: string, run: Partial<Run>): Promise<void> {
-        throw new Error('Function not implemented.');
-    }
+    }): 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>;
+    listRuns(threadId: string, options?: { limit?: number; offset?: number; status?: RunStatus }): Promise<Run[]>;
+    updateRun(runId: string, run: Partial<Run>): Promise<void>;
 }

package/src/types.ts

@@ -9,6 +9,7 @@ import {
     OnConflictBehavior,
     ThreadStatus,
     Checkpoint,
+    Config,
 } from '@langchain/langgraph-sdk';
 import { StreamEvent } from '@langchain/core/tracers/log_stream';
 import { EventMessage } from './queue/event_message';
@@ -87,6 +88,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(