@langgraph-js/sdk 1.7.11 → 1.8.0

package/dist/server/tools/sequential-thinking.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const SequentialThinkingTool: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    thought: z.ZodString;
+    nextThoughtNeeded: z.ZodBoolean;
+    thoughtNumber: z.ZodNumber;
+    totalThoughts: z.ZodNumber;
+    isRevision: z.ZodOptional<z.ZodBoolean>;
+    revisesThought: z.ZodOptional<z.ZodNumber>;
+    branchFromThought: z.ZodOptional<z.ZodNumber>;
+    branchId: z.ZodOptional<z.ZodString>;
+    needsMoreThoughts: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}>, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, string>;

package/dist/server/tools/sequential-thinking.js

@@ -0,0 +1,69 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+const schema = z.object({
+    thought: z.string().describe("Your current thinking step"),
+    nextThoughtNeeded: z.boolean().describe("Whether another thought step is needed"),
+    thoughtNumber: z.number().min(1).describe("Current thought number"),
+    totalThoughts: z.number().min(1).describe("Estimated total thoughts needed"),
+    isRevision: z.boolean().optional().describe("Whether this revises previous thinking"),
+    revisesThought: z.number().min(1).optional().describe("Which thought is being reconsidered"),
+    branchFromThought: z.number().min(1).optional().describe("Branching point thought number"),
+    branchId: z.string().optional().describe("Branch identifier"),
+    needsMoreThoughts: z.boolean().optional().describe("If more thoughts are needed"),
+});
+// 存储思考历史
+const thoughtHistory = [];
+const branches = {};
+export const SequentialThinkingTool = tool(async (args) => {
+    try {
+        if (args.thoughtNumber > args.totalThoughts) {
+            args.totalThoughts = args.thoughtNumber;
+        }
+        thoughtHistory.push(args);
+        if (args.branchFromThought && args.branchId) {
+            if (!branches[args.branchId]) {
+                branches[args.branchId] = [];
+            }
+            branches[args.branchId].push(args);
+        }
+        return JSON.stringify({
+            thoughtNumber: args.thoughtNumber,
+            totalThoughts: args.totalThoughts,
+            nextThoughtNeeded: args.nextThoughtNeeded,
+            branches: Object.keys(branches),
+            thoughtHistoryLength: thoughtHistory.length,
+        }, null, 2);
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: error instanceof Error ? error.message : String(error),
+            status: "failed",
+        }, null, 2);
+    }
+}, {
+    name: "sequential-thinking",
+    description: `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
+
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+
+Key features:
+- You can adjust total_thoughts up or down as you progress
+- You can question or revise previous thoughts
+- You can add more thoughts even after reaching what seemed like the end
+- You can express uncertainty and explore alternative approaches
+- Not every thought needs to build linearly - you can branch or backtrack
+- Generates a solution hypothesis
+- Verifies the hypothesis based on the Chain of Thought steps
+- Repeats the process until satisfied
+- Provides a correct answer`,
+    schema,
+});

package/dist/server/utils.d.ts

@@ -0,0 +1,3 @@
+import { BaseMessage, HumanMessage } from "@langchain/core/messages";
+export declare const getTextMessageContent: (message: BaseMessage) => string;
+export declare function getLastHumanMessage(messages: BaseMessage[]): HumanMessage | undefined;

package/dist/server/utils.js

@@ -0,0 +1,24 @@
+import { isHumanMessage } from "@langchain/core/messages";
+export const getTextMessageContent = (message) => {
+    if (typeof message.content === "string") {
+        return message.content;
+    }
+    else {
+        return message.content
+            .filter((i) => i.type === "text")
+            .map((i) => i.text)
+            .join("\n");
+    }
+};
+export function getLastHumanMessage(messages) {
+    // 从后往前遍历消息列表
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        // 检查消息是否是 HumanMessage 的实例
+        if (isHumanMessage(message)) {
+            return message;
+        }
+    }
+    // 如果没有找到 HumanMessage，则返回 undefined
+    return undefined;
+}

package/dist/tool/createTool.d.ts

@@ -2,16 +2,17 @@ import { z, ZodRawShape, ZodTypeAny } from "zod";
 import { Action, Parameter } from "./copilotkit-actions.js";
 import { Message } from "@langchain/langgraph-sdk";
 import { ToolRenderData } from "./ToolUI.js";
-export interface UnionTool<Args extends ZodRawShape, Child extends Object = Object> {
+export interface UnionTool<Args extends ZodRawShape, Child extends Object = Object, D = any> {
     name: string;
     description: string;
     parameters: Args;
     /** 是否直接返回工具结果，而不是通过消息返回 */
     returnDirect?: boolean;
-    execute: ToolCallback<Args>;
+    execute?: ToolCallback<Args>;
     /** 工具执行成功后触发的附加消息 */
     callbackMessage?: (result: CallToolResult) => Message[];
-    render?: <D>(tool: ToolRenderData<z.objectOutputType<Args, ZodTypeAny>, D>) => Child;
+    handler?: (args: z.objectOutputType<Args, ZodTypeAny>, context?: any) => D | Promise<D>;
+    render?: (tool: ToolRenderData<z.objectOutputType<Args, ZodTypeAny>, D>) => Child;
     onlyRender?: boolean;
     /** 只允许指定的 agent 使用该工具，如果未指定，则所有 agent 都可以使用 */
     allowAgent?: string[];
@@ -24,13 +25,20 @@ export type CallToolResult = string | {
     text: string;
 }[];
 /** 用于格式校验 */
-export declare const createTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => UnionTool<Args, Object>;
-/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
+export declare const createTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => UnionTool<Args, Object, any>;
+/**
+ * create Type Safe Tool with zod and UI Render Feature
+ */
+export declare const createUITool: <Args extends ZodRawShape, Child extends Object = {}>(tool: UnionTool<Args, Child>) => UnionTool<Args, Child>;
+/**
+ * 提供一种兼容 copilotkit 的定义方式，简化定义形式
  * 来自 copilotkit 的 frontend action
  */
-export declare const createFETool: <const T extends Parameter[], Args extends ZodRawShape>(tool: Action<T> & {
+export declare const createFETool: <const T extends Parameter[], Args extends ZodRawShape, Child extends Object = {}>(tool: Action<T> & {
     allowAgent?: string[];
     allowGraph?: string[];
+    render?: (tool: ToolRenderData<any, any>) => Child;
+    onlyRender?: boolean;
 }) => UnionTool<Args>;
 export declare const createJSONDefineTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
     name: string;
@@ -48,6 +56,12 @@ export declare const createMCPTool: <Args extends ZodRawShape>(tool: UnionTool<A
         text: string;
     }[];
     isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[] | undefined;
+    isError?: undefined;
 } | {
     content: {
         type: string;
@@ -55,24 +69,12 @@ export declare const createMCPTool: <Args extends ZodRawShape>(tool: UnionTool<A
     }[];
     isError: boolean;
 }>))[];
-export declare const createToolUI: <Args extends Parameter[] | [] = [], Child extends Object = {}>(tool: Action<Args> & {
+/**
+ * @deprecated Use createUITool instead
+ */
+export declare const createToolUI: <const T extends Parameter[], Args extends ZodRawShape, Child extends Object = {}>(tool: Action<T> & {
     allowAgent?: string[];
     allowGraph?: string[];
     render?: (tool: ToolRenderData<any, any>) => Child;
     onlyRender?: boolean;
-}) => {
-    render: ((tool: ToolRenderData<any, any>) => Child) | undefined;
-    onlyRender: boolean | undefined;
-    name: string;
-    description: string;
-    parameters: z.ZodRawShape;
-    /** 是否直接返回工具结果，而不是通过消息返回 */
-    returnDirect?: boolean;
-    execute: ToolCallback<z.ZodRawShape>;
-    /** 工具执行成功后触发的附加消息 */
-    callbackMessage?: (result: CallToolResult) => Message[];
-    /** 只允许指定的 agent 使用该工具，如果未指定，则所有 agent 都可以使用 */
-    allowAgent?: string[];
-    /** 只允许指定的 Graph 使用该工具 */
-    allowGraph?: string[];
-};
+}) => UnionTool<Args>;

package/dist/tool/createTool.js

@@ -5,11 +5,35 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 export const createTool = (tool) => {
     return tool;
 };
-/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
+/**
+ * create Type Safe Tool with zod and UI Render Feature
+ */
+export const createUITool = (tool) => {
+    return {
+        ...tool,
+        async execute(args, context) {
+            var _a;
+            try {
+                const result = await ((_a = tool.handler) === null || _a === void 0 ? void 0 : _a.call(tool, args, context));
+                if (typeof result === "string") {
+                    return [{ type: "text", text: result }];
+                }
+                return [{ type: "text", text: JSON.stringify(result) }];
+            }
+            catch (error) {
+                return [{ type: "text", text: `Error: ${error}` }];
+            }
+        },
+    };
+};
+/**
+ * 提供一种兼容 copilotkit 的定义方式，简化定义形式
  * 来自 copilotkit 的 frontend action
  */
 export const createFETool = (tool) => {
     return {
+        render: tool.render,
+        onlyRender: tool.onlyRender,
         name: tool.name,
         description: tool.description || "",
         parameters: convertJsonSchemaToZodRawShape(actionParametersToJsonSchema(tool.parameters || [])),
@@ -46,8 +70,9 @@ export const createMCPTool = (tool) => {
         tool.description,
         tool.parameters,
         async (args) => {
+            var _a;
             try {
-                const result = await tool.execute(args);
+                const result = await ((_a = tool.execute) === null || _a === void 0 ? void 0 : _a.call(tool, args));
                 if (typeof result === "string") {
                     return { content: [{ type: "text", text: result }] };
                 }
@@ -61,10 +86,7 @@ export const createMCPTool = (tool) => {
         },
     ];
 };
-export const createToolUI = (tool) => {
-    return {
-        ...createFETool(tool),
-        render: tool.render,
-        onlyRender: tool.onlyRender,
-    };
-};
+/**
+ * @deprecated Use createUITool instead
+ */
+export const createToolUI = createFETool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langgraph-js/sdk",
-  "version": "1.7.11",
+  "version": "1.8.0",
   "description": "The UI SDK for LangGraph - seamlessly integrate your AI agents with frontend interfaces",
   "main": "dist/index.js",
   "type": "module",