@langgraph-js/pure-graph 1.0.2 → 1.3.0

package/dist/adapter/nextjs/router.js

@@ -0,0 +1,179 @@
+/** @ts-ignore */
+import { NextResponse } from 'next/server';
+import { client } from './endpoint';
+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) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const { event, data } of generator) {
+                    const line = `event: ${event}\n` + `data: ${serialiseAsDict(data, 0)}\n\n`;
+                    controller.enqueue(encoder.encode(line));
+                }
+            }
+            catch (err) {
+                // ignore
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+        },
+    });
+}
+// 统一路由处理器
+export async function GET(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    // Assistants routes
+    if (pathname.match(/\/assistants\/[^/]+\/graph$/)) {
+        const match = pathname.match(/\/assistants\/([^/]+)\/graph$/);
+        if (match) {
+            const assistant_id = match[1];
+            const xrayParam = url.searchParams.get('xray');
+            const queryParams = { xray: xrayParam };
+            const { xray } = AssistantGraphQuerySchema.parse(queryParams);
+            const data = await client.assistants.getGraph(assistant_id, {
+                xray: xray !== undefined ? xray === 'true' : undefined,
+            });
+            return NextResponse.json(data);
+        }
+    }
+    // Threads routes
+    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}$/)) {
+        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})$/);
+        if (match) {
+            const thread_id = match[1];
+            const data = await client.threads.get(thread_id);
+            return NextResponse.json(data);
+        }
+    }
+    // Runs routes
+    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/runs$/)) {
+        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 queryParams = { limit, offset, status };
+            const { limit: parsedLimit, offset: parsedOffset, status: parsedStatus, } = RunListQuerySchema.parse(queryParams);
+            const runs = await client.runs.list(thread_id, {
+                limit: parsedLimit,
+                offset: parsedOffset,
+                status: parsedStatus,
+            });
+            return Response.json(runs);
+        }
+    }
+    return new NextResponse('Not Found', { status: 404 });
+}
+export async function POST(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    // Assistants routes
+    if (pathname.endsWith('/assistants/search')) {
+        const body = await req.json();
+        const payload = AssistantsSearchSchema.parse(body);
+        const data = await client.assistants.search({
+            graphId: payload.graph_id,
+            metadata: payload.metadata,
+            limit: payload.limit,
+            offset: payload.offset,
+        });
+        return NextResponse.json(data, {
+            headers: { 'X-Pagination-Total': String(data.length) },
+        });
+    }
+    // Threads routes
+    if (pathname.endsWith('/threads')) {
+        const body = await req.json();
+        const payload = ThreadCreatePayloadSchema.parse(body);
+        const thread = await client.threads.create({
+            thread_id: payload.thread_id,
+            metadata: payload.metadata,
+            if_exists: payload.if_exists ?? undefined,
+        });
+        return NextResponse.json(thread);
+    }
+    if (pathname.endsWith('/threads/search')) {
+        const body = await req.json();
+        const payload = ThreadSearchPayloadSchema.parse(body);
+        const result = await client.threads.search({
+            metadata: payload.metadata,
+            status: payload.status,
+            limit: payload.limit,
+            offset: payload.offset,
+            sortBy: payload.sort_by ?? undefined,
+            sortOrder: payload.sort_order ?? undefined,
+        });
+        return NextResponse.json(result, {
+            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$/);
+        if (match) {
+            const thread_id = match[1];
+            const body = await req.json();
+            const payload = RunStreamPayloadSchema.parse(body);
+            const generator = client.runs.stream(thread_id, payload.assistant_id, payload);
+            return sseResponse(generator);
+        }
+    }
+    // Runs routes - cancel
+    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}\/runs\/[0-9a-fA-F-]{36}\/cancel$/)) {
+        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})\/runs\/([0-9a-fA-F-]{36})\/cancel$/);
+        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 queryParams = {
+                wait: waitParam ? waitParam === 'true' : false,
+                action: actionParam ?? 'interrupt',
+            };
+            const { wait, action } = RunCancelQuerySchema.parse(queryParams);
+            const promise = client.runs.cancel(thread_id, run_id, wait, action);
+            if (wait)
+                await promise;
+            return new Response(null, { status: wait ? 204 : 202 });
+        }
+    }
+    return new NextResponse('Not Found', { status: 404 });
+}
+export async function DELETE(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    // Threads routes
+    if (pathname.match(/\/threads\/[0-9a-fA-F-]{36}$/)) {
+        const match = pathname.match(/\/threads\/([0-9a-fA-F-]{36})$/);
+        if (match) {
+            const thread_id = match[1];
+            await client.threads.delete(thread_id);
+            return new NextResponse(null, { status: 204 });
+        }
+    }
+    return new NextResponse('Not Found', { status: 404 });
+}

package/dist/adapter/nextjs/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;
+    metadata: {} & {
+        [k: string]: any;
+    };
+    graph_id: string;
+    assistant_id: string;
+    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;
+    metadata: {} & {
+        [k: string]: any;
+    };
+    graph_id: string;
+    assistant_id: string;
+    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/nextjs/zod.js

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