@langgraph-js/pure-graph 1.0.1 → 1.2.0

package/examples/nextjs/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "nextjs",
+    "version": "0.1.0",
+    "private": true,
+    "scripts": {
+        "dev": "next dev --turbopack",
+        "build": "next build --turbopack",
+        "start": "next start"
+    },
+    "dependencies": {
+        "@langgraph-js/pure-graph": "workspace:^*",
+        "next": "15.5.4",
+        "react": "19.1.0",
+        "react-dom": "19.1.0"
+    },
+    "devDependencies": {
+        "@tailwindcss/postcss": "^4",
+        "@types/node": "^20",
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+        "tailwindcss": "^4",
+        "typescript": "^5"
+    }
+}

package/examples/nextjs/postcss.config.mjs

@@ -0,0 +1,5 @@
+const config = {
+  plugins: ["@tailwindcss/postcss"],
+};
+
+export default config;

package/examples/nextjs/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES2017",
+        "lib": ["dom", "dom.iterable", "esnext"],
+        "allowJs": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "noEmit": true,
+        "esModuleInterop": true,
+        "module": "esnext",
+        "moduleResolution": "bundler",
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "jsx": "preserve",
+        "incremental": true,
+        "plugins": [
+            {
+                "name": "next"
+            }
+        ],
+        "paths": {
+            "@/*": ["./*"]
+        }
+    },
+    "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    "exclude": ["node_modules"]
+}

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "@langgraph-js/pure-graph",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/index.js",
   "keywords": [],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "^0.3.77",
+    "@langchain/core": "^0.3.78",
     "@langchain/langgraph": "^0.4.9",
     "@langchain/langgraph-checkpoint": "^0.1.1",
+    "@langchain/langgraph-checkpoint-sqlite": "^0.2.1",
     "@langgraph-js/pro": "^1.8.1",
+    "better-sqlite3": "^12.4.1",
     "eventemitter3": "^5.0.1",
     "zod": "^3"
   },
   "optionalDependencies": {
     "@hono/zod-validator": "^0.7.3",
-    "hono": "^4.9.9"
+    "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",
     "@types/node": "^22.13.5",
     "typescript": "^5.9.2"
   },
   "scripts": {
     "dev": "bun run test/hono.ts",
-    "build": "tsc"
+    "build": " tsc",
+    "prepublish": "pnpm build"
   }
 }

package/packages/agent-graph/demo.json

@@ -0,0 +1,35 @@
+{
+    "agent_protocol": {
+        "id": "novel-writing-assistant",
+        "protocolVersion": "1.0.0",
+        "name": "小说创作助手",
+        "description": "专业的AI小说创作助手，提供情节构思、人物塑造、世界观构建和写作指导的全方位服务",
+        "url": "https://api.novelai.net/ai/generate",
+        "iconUrl": "https://img.icons8.com/fluency/96/000000/book.png",
+        "version": "2.0.1",
+        "documentationUrl": "https://docs.novelai.net/",
+        "llm": [
+            {
+                "provider": "openai",
+                "model": "gpt-4o-mini"
+            },
+            {
+                "provider": "openai",
+                "model": "qwen-plus"
+            }
+        ],
+        "systemPrompt": "你是一位经验丰富的小说家和创意写作导师，精通各种文学体裁和叙事技巧。你善于分析经典作品的结构，帮助创作者构建引人入胜的情节、塑造立体的人物形象，并提供专业的写作建议和灵感启发。",
+        "tools": [
+            {
+                "tool_type": "mcp",
+                "url": "https://mcp.exa.ai/mcp?exaApiKey=ce1249b7-6b78-4ec8-8be9-41823b5d2365",
+                "headers": {}
+            },
+            {
+                "tool_type": "builtin",
+                "name": "tavily_search"
+            }
+        ],
+        "subAgents": []
+    }
+}

package/packages/agent-graph/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "packages",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "@langchain/mcp-adapters": "^0.6.0",
+        "@langchain/openai": "^0.6.14",
+        "@langchain/tavily": "^0.1.5",
+        "@langgraph-js/pure-graph": "workspace:^*"
+    }
+}

package/packages/agent-graph/src/index.ts

@@ -0,0 +1,47 @@
+import { Annotation, entrypoint } from '@langchain/langgraph';
+import { createState } from '@langgraph-js/pro';
+import { AgentProtocol } from './types';
+import { createReactAgent, createReactAgentAnnotation } from '@langchain/langgraph/prebuilt';
+import { ChatOpenAI } from '@langchain/openai';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { createTools } from './tools';
+import { createEntrypointGraph } from '@langgraph-js/pure-graph';
+const AgentProtocolState = createState().build({
+    agent_protocol: Annotation<AgentProtocol>(),
+    model_name: Annotation<string>(),
+});
+
+const AgentGraphState = createState(AgentProtocolState, createReactAgentAnnotation()).build({});
+
+export const createLLM = async (protocol: AgentProtocol, model_name?: string): Promise<BaseChatModel> => {
+    if (!model_name) {
+        model_name = protocol.llm[0].model;
+    } else {
+        const llm = protocol.llm.find((i) => i.model === model_name);
+        if (!llm) {
+            throw new Error(`Model ${model_name} not found`);
+        }
+        model_name = llm.model;
+    }
+    return new ChatOpenAI({
+        model: model_name,
+    });
+};
+
+export const graph = createEntrypointGraph({
+    stateSchema: AgentGraphState,
+    graph: entrypoint({ name: 'agent-graph' }, async (state: typeof AgentGraphState.State) => {
+        const protocol = state.agent_protocol;
+
+        const tools = await createTools(protocol);
+
+        const agent = createReactAgent({
+            llm: await createLLM(protocol, state.model_name),
+            tools,
+            prompt: protocol.systemPrompt,
+            stateSchema: AgentGraphState,
+        });
+        const response = await agent.invoke(state);
+        return response;
+    }),
+});

package/packages/agent-graph/src/tools/tavily.ts

@@ -0,0 +1,9 @@
+import { TavilyExtract, TavilySearch } from '@langchain/tavily';
+export const tavily_search = new TavilySearch({
+    maxResults: 5,
+    apiBaseUrl: process.env.TAVILY_HOST,
+});
+
+export const tavily_extract = new TavilyExtract({
+    apiBaseUrl: process.env.TAVILY_HOST,
+});

package/packages/agent-graph/src/tools.ts

@@ -0,0 +1,38 @@
+import { AgentProtocol } from './types';
+import { StructuredTool } from '@langchain/core/tools';
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import * as tavily from './tools/tavily';
+const prebuiltTools: Record<string, StructuredTool> = {
+    ...tavily,
+};
+
+export const createPrebuiltTools = async (protocol: AgentProtocol): Promise<StructuredTool[]> => {
+    const PrebuiltConfigs = protocol.tools.filter((i) => i.tool_type === 'builtin');
+    if (PrebuiltConfigs.length === 0) {
+        return [];
+    }
+    return PrebuiltConfigs.map((i) => prebuiltTools[i.name]);
+};
+
+export const createMCPTools = async (protocol: AgentProtocol): Promise<StructuredTool[]> => {
+    const MCPConfigs = protocol.tools.filter((i) => i.tool_type === 'mcp');
+    if (MCPConfigs.length === 0) {
+        return [];
+    }
+    const client = new MultiServerMCPClient({
+        mcpServers: Object.fromEntries(
+            MCPConfigs.map((i) => [
+                i.name,
+                {
+                    url: i.url,
+                    headers: i.headers,
+                },
+            ]),
+        ),
+    });
+    return client.getTools();
+};
+
+export const createTools = async (protocol: AgentProtocol): Promise<StructuredTool[]> => {
+    return [...(await createMCPTools(protocol)), ...(await createPrebuiltTools(protocol))];
+};

package/packages/agent-graph/src/types.ts

@@ -0,0 +1,42 @@
+export interface AgentTool {
+    name: string;
+    tool_type: string;
+    description?: string;
+}
+
+export interface MCPTool extends AgentTool {
+    tool_type: 'mcp';
+    type: string;
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface BuiltinTool extends AgentTool {
+    tool_type: 'builtin';
+}
+
+export interface InnerTool extends AgentTool {
+    tool_type: 'inner';
+}
+
+export interface SubAgent {
+    protocolId: string;
+    protocol?: AgentProtocol;
+}
+
+export interface AgentProtocol {
+    id: string;
+    protocolVersion: string;
+    name: string;
+    description: string;
+    url: string;
+    iconUrl?: string;
+    version: string;
+    documentationUrl?: string;
+    llm: {
+        provider?: string;
+        model: string;
+    }[];
+    systemPrompt: string;
+    tools: (BuiltinTool | InnerTool | MCPTool)[];
+    subAgents: SubAgent[];
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+packages:
+    # 指定根目录直接子目录中的包
+    - "packages/*"
+    - "examples/*"

package/src/adapter/hono/assistants.ts

@@ -1,41 +1,24 @@
 import { zValidator } from '@hono/zod-validator';
 import { Hono } from 'hono';
-import { z } from 'zod';
 import { client } from './endpoint';
-import { MetadataSchema } from './zod';
+import { AssistantsSearchSchema, AssistantGraphQuerySchema } 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.post('/assistants/search', zValidator('json', AssistantsSearchSchema), 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);
-    },
-);
+api.get('/assistants/:assistant_id/graph', zValidator('query', AssistantGraphQuerySchema), 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/src/adapter/hono/endpoint.ts

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

package/src/adapter/hono/runs.ts

@@ -2,9 +2,14 @@ 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 {
+    ThreadIdParamSchema,
+    RunIdParamSchema,
+    RunStreamPayloadSchema,
+    RunListQuerySchema,
+    RunCancelQuerySchema,
+} from '../zod';
 import { serialiseAsDict } from '../../graph/stream';
 
 const api = new Hono();
@@ -12,36 +17,8 @@ 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.'),
-    ),
+    zValidator('param', ThreadIdParamSchema),
+    zValidator('json', RunStreamPayloadSchema),
     async (c) => {
         // Stream Run
         const { thread_id } = c.req.valid('param');
@@ -51,7 +28,7 @@ api.post(
         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.writeSSE({ data: serialiseAsDict(data) ?? '', event });
             }
         });
     },
@@ -59,33 +36,20 @@ api.post(
 
 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(),
-        }),
-    ),
+    zValidator('param', ThreadIdParamSchema),
+    zValidator('query', RunListQuerySchema),
     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 });
+        const runs = await client.runs.list(thread_id, { limit, 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'),
-        }),
-    ),
+    zValidator('param', RunIdParamSchema),
+    zValidator('query', RunCancelQuerySchema),
     async (c) => {
         // Cancel Run Http
         const { thread_id, run_id } = c.req.valid('param');

package/src/adapter/hono/threads.ts

@@ -1,88 +1,33 @@
 import { zValidator } from '@hono/zod-validator';
 import { Hono } from 'hono';
-import { z } from 'zod';
 import { client } from './endpoint';
-import { CommandSchema, MetadataSchema } from './zod';
+import { ThreadIdParamSchema, ThreadCreatePayloadSchema, ThreadSearchPayloadSchema } 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);
+api.post('/threads', zValidator('json', ThreadCreatePayloadSchema), async (c) => {
+    const payload = c.req.valid('json');
+    const thread = await client.threads.create(payload);
 
-        return c.json(thread);
-    },
-);
+    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 as any);
-        c.res.headers.set('X-Pagination-Total', result.length.toString());
-        return c.json(result);
-    },
-);
+api.post('/threads/search', zValidator('json', ThreadSearchPayloadSchema), async (c) => {
+    // Search Threads
+    const payload = c.req.valid('json');
+    const result = await client.threads.search(payload as any);
+    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) => {
+api.get('/threads/:thread_id', zValidator('param', ThreadIdParamSchema), 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) => {
+api.delete('/threads/:thread_id', zValidator('param', ThreadIdParamSchema), async (c) => {
     // Delete Thread
     const { thread_id } = c.req.valid('param');
     await client.threads.delete(thread_id);

package/src/adapter/nextjs/endpoint.ts

@@ -0,0 +1,2 @@
+import { createEndpoint } from '../../createEndpoint.js';
+export const client = createEndpoint();

package/src/adapter/nextjs/index.ts

@@ -0,0 +1,2 @@
+// 统一路由处理器
+export { GET, POST, DELETE } from "./router";