@langgraph-js/pure-graph 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# Pure Graph
+
+Pure Graph is a project that implements a Standard LangGraph Endpoint to many frameworks like NextJS and NuxtJS.
+
+```js
+import { registerGraph } from '../src/createEndpoint';
+import { graph } from './graph/index';
+import { Hono } from 'hono';
+import LangGraphApp from '../src/adapter/hono/index';
+registerGraph('test', graph);
+
+const app = new Hono();
+app.route('/', LangGraphApp);
+
+export default app;
+```

package/dist/adapter/hono/assistants.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/adapter/hono/assistants.js

@@ -0,0 +1,27 @@
+import { zValidator } from '@hono/zod-validator';
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { client } from './endpoint';
+import { MetadataSchema } from './zod';
+const api = new Hono();
+api.post('/assistants/search', zValidator('json', z.object({
+    graph_id: z.string().optional(),
+    metadata: MetadataSchema.optional(),
+    limit: z.number().int().optional(),
+    offset: z.number().int().optional(),
+})), async (c) => {
+    // Search Assistants
+    const payload = c.req.valid('json');
+    let total = 0;
+    const data = await client.assistants.search(payload);
+    c.res.headers.set('X-Pagination-Total', total.toString());
+    return c.json(data);
+});
+api.get('/assistants/:assistant_id/graph', zValidator('query', z.object({ xray: z.string().optional() })), async (c) => {
+    const xray = c.req.valid('query').xray;
+    const data = await client.assistants.getGraph(c.req.param('assistant_id'), {
+        xray: xray !== undefined ? xray === 'true' : undefined,
+    });
+    return c.json(data);
+});
+export default api;

package/dist/adapter/hono/endpoint.d.ts

@@ -0,0 +1 @@
+export declare const client: import("../../types.js").ILangGraphClient<unknown>;

package/dist/adapter/hono/endpoint.js

@@ -0,0 +1,3 @@
+import { createEndpoint } from '../../createEndpoint.js';
+import { MemoryThreadsManager } from '../../storage/memory/threads.js';
+export const client = createEndpoint(new MemoryThreadsManager());

package/dist/adapter/hono/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/adapter/hono/index.js

@@ -0,0 +1,11 @@
+import { Hono } from 'hono';
+import Assistants from './assistants';
+import Runs from './runs';
+import Threads from './threads';
+import { cors } from 'hono/cors';
+const app = new Hono();
+app.use(cors());
+app.route('/', Assistants);
+app.route('/', Runs);
+app.route('/', Threads);
+export default app;

package/dist/adapter/hono/runs.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/adapter/hono/runs.js

@@ -0,0 +1,71 @@
+import { zValidator } from '@hono/zod-validator';
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { z } from 'zod';
+import { client } from './endpoint';
+import { AssistantConfig, CommandSchema, MetadataSchema } from './zod';
+import { serialiseAsDict } from '../../graph/stream';
+const api = new Hono();
+// 最常用的对话接口
+api.post('/threads/:thread_id/runs/stream', zValidator('param', z.object({ thread_id: z.string().uuid() })), zValidator('json', z
+    .object({
+    assistant_id: z.union([z.string().uuid(), z.string()]),
+    checkpoint_id: z.string().optional(),
+    // checkpoint: CheckpointSchema.optional(),
+    input: z.any().optional(),
+    command: CommandSchema.optional(),
+    metadata: MetadataSchema.optional(),
+    config: AssistantConfig.optional(),
+    webhook: z.string().optional(),
+    interrupt_before: z.union([z.literal('*'), z.array(z.string())]).optional(),
+    interrupt_after: z.union([z.literal('*'), z.array(z.string())]).optional(),
+    on_disconnect: z.enum(['cancel', 'continue']).optional().default('continue'),
+    multitask_strategy: z.enum(['reject', 'rollback', 'interrupt', 'enqueue']).optional(),
+    stream_mode: z
+        .array(z.enum(['values', 'messages', 'messages-tuple', 'updates', 'events', 'debug', 'custom']))
+        .optional(),
+    stream_subgraphs: z.boolean().optional(),
+    stream_resumable: z.boolean().optional(),
+    after_seconds: z.number().optional(),
+    if_not_exists: z.enum(['create', 'reject']).optional(),
+    on_completion: z.enum(['complete', 'continue']).optional(),
+    feedback_keys: z.array(z.string()).optional(),
+    langsmith_tracer: z.unknown().optional(),
+})
+    .describe('Payload for creating a stateful run.')), async (c) => {
+    // Stream Run
+    const { thread_id } = c.req.valid('param');
+    const payload = c.req.valid('json');
+    // c.header('Content-Location', `/threads/${thread_id}/runs/${run.run_id}`);
+    return streamSSE(c, async (stream) => {
+        /** @ts-ignore zod v3 的问题，与 ts 类型不一致 */
+        for await (const { event, data } of client.runs.stream(thread_id, payload.assistant_id, payload)) {
+            await stream.writeSSE({ data: serialiseAsDict(data), event });
+        }
+        // await stream.sleep(500); // 不知为何要等
+    });
+});
+api.get('/threads/:thread_id/runs', zValidator('param', z.object({ thread_id: z.string().uuid() })), zValidator('query', z.object({
+    limit: z.string().optional(),
+    offset: z.string().optional(),
+    status: z.enum(['pending', 'running', 'error', 'success', 'timeout', 'interrupted']).optional(),
+})), async (c) => {
+    const { thread_id } = c.req.valid('param');
+    const { limit, offset, status } = c.req.valid('query');
+    const runs = await client.runs.list(thread_id, { limit: Number(limit), offset: Number(offset), status });
+    return c.json(runs);
+});
+api.post('/threads/:thread_id/runs/:run_id/cancel', zValidator('param', z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator('query', z.object({
+    wait: z.coerce.boolean().optional().default(false),
+    action: z.enum(['interrupt', 'rollback']).optional().default('interrupt'),
+})), async (c) => {
+    // Cancel Run Http
+    const { thread_id, run_id } = c.req.valid('param');
+    const { wait, action } = c.req.valid('query');
+    const cancel = client.runs.cancel(thread_id, run_id, wait, action);
+    if (wait) {
+        await cancel;
+    }
+    return c.body(null, wait ? 204 : 202);
+});
+export default api;

package/dist/adapter/hono/threads.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/adapter/hono/threads.js

@@ -0,0 +1,71 @@
+import { zValidator } from '@hono/zod-validator';
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { client } from './endpoint';
+import { MetadataSchema } from './zod';
+const api = new Hono();
+// Threads Routes
+api.post('/threads', zValidator('json', z
+    .object({
+    // supersteps: z
+    //     .array(
+    //         z.object({
+    //             updates: z.array(
+    //                 z.object({
+    //                     values: z.unknown(),
+    //                     command: CommandSchema.optional(),
+    //                     as_node: z.string(),
+    //                 }),
+    //             ),
+    //         }),
+    //     )
+    //     .describe('The supersteps to apply to the thread.')
+    //     .optional(),
+    thread_id: z
+        .string()
+        .uuid()
+        .describe('The ID of the thread. If not provided, an ID is generated.')
+        .optional(),
+    metadata: MetadataSchema.optional(),
+    if_exists: z.union([z.literal('raise'), z.literal('do_nothing')]).optional(),
+})
+    .describe('Payload for creating a thread.')), async (c) => {
+    const payload = c.req.valid('json');
+    const thread = await client.threads.create(payload);
+    return c.json(thread);
+});
+api.post('/threads/search', zValidator('json', z
+    .object({
+    metadata: z.record(z.unknown()).describe('Metadata to search for.').optional(),
+    status: z
+        .enum(['idle', 'busy', 'interrupted', 'error'])
+        .describe('Filter by thread status.')
+        .optional(),
+    values: z.record(z.unknown()).describe('Filter by thread values.').optional(),
+    limit: z.number().int().gte(1).lte(1000).describe('Maximum number to return.').optional(),
+    offset: z.number().int().gte(0).describe('Offset to start from.').optional(),
+    sort_by: z
+        .enum(['thread_id', 'status', 'created_at', 'updated_at'])
+        .describe('Sort by field.')
+        .optional(),
+    sort_order: z.enum(['asc', 'desc']).describe('Sort order.').optional(),
+})
+    .describe('Payload for listing threads.')), async (c) => {
+    // Search Threads
+    const payload = c.req.valid('json');
+    const result = await client.threads.search(payload);
+    c.res.headers.set('X-Pagination-Total', result.length.toString());
+    return c.json(result);
+});
+api.get('/threads/:thread_id', zValidator('param', z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Get Thread
+    const { thread_id } = c.req.valid('param');
+    return c.json(await client.threads.get(thread_id));
+});
+api.delete('/threads/:thread_id', zValidator('param', z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Delete Thread
+    const { thread_id } = c.req.valid('param');
+    await client.threads.delete(thread_id);
+    return new Response(null, { status: 204 });
+});
+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/createEndpoint.d.ts

@@ -0,0 +1,5 @@
+import { BaseThreadsManager } from './threads/index.js';
+import { ILangGraphClient } from './types.js';
+export { registerGraph } from './utils/getGraph.js';
+export declare const AssistantEndpoint: ILangGraphClient['assistants'];
+export declare const createEndpoint: (threads: BaseThreadsManager) => ILangGraphClient;

package/dist/createEndpoint.js

@@ -0,0 +1,77 @@
+import { streamState } from './graph/stream.js';
+import { getGraph, GRAPHS } from './utils/getGraph.js';
+import { globalMessageQueue } from './global.js';
+export { registerGraph } from './utils/getGraph.js';
+export const AssistantEndpoint = {
+    async search(query) {
+        if (query?.graphId) {
+            return [
+                {
+                    assistant_id: query.graphId,
+                    graph_id: query.graphId,
+                    config: {},
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                    metadata: {},
+                    version: 1,
+                    name: query.graphId,
+                    description: '',
+                },
+            ];
+        }
+        return Object.entries(GRAPHS).map(([graphId, _]) => ({
+            assistant_id: graphId,
+            graph_id: graphId,
+            config: {},
+            metadata: {},
+            version: 1,
+            name: graphId,
+            description: '',
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        }));
+    },
+    async getGraph(assistantId, options) {
+        const config = {};
+        const graph = await getGraph(assistantId, config);
+        const drawable = await graph.getGraphAsync({
+            ...config,
+            xray: options?.xray ?? undefined,
+        });
+        return drawable.toJSON();
+    },
+};
+export const createEndpoint = (threads) => {
+    return {
+        assistants: AssistantEndpoint,
+        threads,
+        runs: {
+            list(threadId, options) {
+                return threads.listRuns(threadId, options);
+            },
+            async cancel(threadId, runId, wait, action) {
+                return globalMessageQueue.cancelQueue(runId);
+            },
+            async *stream(threadId, assistantId, payload) {
+                if (!payload.config) {
+                    payload.config = {
+                        configurable: {
+                            graph_id: assistantId,
+                            thread_id: threadId,
+                        },
+                    };
+                }
+                const run = threads.createRun(threadId, assistantId, payload);
+                for await (const data of streamState(threads, run, payload, {
+                    attempt: 0,
+                    getGraph,
+                })) {
+                    yield data;
+                }
+            },
+            joinStream(threadId, runId, options) {
+                throw new Error('Function not implemented.');
+            },
+        },
+    };
+};

package/dist/global.d.ts

@@ -0,0 +1,4 @@
+/** 全局队列管理器 */
+export declare const globalMessageQueue: import("./queue/stream_queue.js").StreamQueueManager<import("./storage/memory/queue.js").MemoryStreamQueue>;
+/** 全局 Checkpointer */
+export declare const globalCheckPointer: import("@langchain/langgraph-checkpoint").MemorySaver;

package/dist/global.js

@@ -0,0 +1,5 @@
+import { createCheckPointer, createMessageQueue } from './storage/index.js';
+/** 全局队列管理器 */
+export const globalMessageQueue = createMessageQueue();
+/** 全局 Checkpointer */
+export const globalCheckPointer = createCheckPointer();

package/dist/graph/stream.d.ts

@@ -0,0 +1,39 @@
+import type { BaseCheckpointSaver, LangGraphRunnableConfig } from '@langchain/langgraph';
+import type { Pregel } from '@langchain/langgraph/pregel';
+import type { BaseStreamQueueInterface } from '../queue/stream_queue.js';
+import { Run } from '@langgraph-js/sdk';
+import { EventMessage } from '../queue/event_message.js';
+import { BaseThreadsManager } from '../threads/index.js';
+import { StreamInputData } from '../types.js';
+export type LangGraphStreamMode = Pregel<any, any>['streamMode'][number];
+export declare function streamStateWithQueue(threads: BaseThreadsManager, run: Run, queue: BaseStreamQueueInterface, payload: StreamInputData, options: {
+    attempt: number;
+    getGraph: (graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+        checkpointer?: BaseCheckpointSaver | null;
+    }) => Promise<Pregel<any, any, any, any, any>>;
+    compressMessages?: boolean;
+}): Promise<void>;
+/**
+ * 从队列创建数据流生成器
+ * @param queueId 队列 ID
+ * @param signal 中止信号
+ * @returns 数据流生成器
+ */
+export declare function createStreamFromQueue(queueId: string): AsyncGenerator<{
+    event: string;
+    data: unknown;
+}>;
+export declare const serialiseAsDict: (obj: unknown) => string;
+/**
+ * 兼容性函数：保持原有 API，同时使用队列模式
+ * @param run 运行配置
+ * @param options 选项
+ * @returns 数据流生成器
+ */
+export declare function streamState(threads: BaseThreadsManager, run: Run | Promise<Run>, payload: StreamInputData, options: {
+    attempt: number;
+    getGraph: (graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+        checkpointer?: BaseCheckpointSaver | null;
+    }) => Promise<Pregel<any, any, any, any, any>>;
+    compressMessages?: boolean;
+}): AsyncGenerator<EventMessage, void, unknown>;