@langgraph-js/sdk 1.7.1 → 1.7.5

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

@@ -1,14 +1,15 @@
 import { RenderMessage } from "../LangGraphClient.js";
 import { LangGraphClient } from "../LangGraphClient.js";
-export declare class ToolRenderData<D> {
+export declare class ToolRenderData<I, D> {
     message: RenderMessage;
     client: LangGraphClient;
     constructor(message: RenderMessage, client: LangGraphClient);
-    get state(): "idle" | "done";
-    get input(): any;
+    get state(): "idle" | "done" | "loading";
+    get input(): I | null;
     get output(): string;
-    getJSONOutput(): any;
+    getJSONOutput(): D;
     /** 如果解析失败，则返回 null */
-    getJSONOutputSafe(): any;
+    getJSONOutputSafe(): D | null;
+    getInputRepaired(): I | null;
     response(data: D): void;
 }

package/dist/tool/ToolUI.js

@@ -1,4 +1,5 @@
 import { getMessageContent } from "../ui-store/createChatStore.js";
+import { jsonrepair } from "jsonrepair";
 export class ToolRenderData {
     constructor(message, client) {
         this.message = message;
@@ -9,6 +10,9 @@ export class ToolRenderData {
         if (this.message.type === "tool" && ((_b = (_a = this.message) === null || _a === void 0 ? void 0 : _a.additional_kwargs) === null || _b === void 0 ? void 0 : _b.done)) {
             return "done";
         }
+        if (this.message.tool_input) {
+            return "loading";
+        }
         return "idle";
     }
     get input() {
@@ -34,6 +38,14 @@ export class ToolRenderData {
             return null;
         }
     }
+    getInputRepaired() {
+        try {
+            return JSON.parse(jsonrepair(this.message.tool_input || ""));
+        }
+        catch (e) {
+            return null;
+        }
+    }
     response(data) {
         this.client.doneFEToolWaiting(this.message.id, JSON.stringify(data));
     }

package/dist/tool/createTool.d.ts

@@ -11,7 +11,7 @@ export interface UnionTool<Args extends ZodRawShape, Child extends Object = Obje
     execute: ToolCallback<Args>;
     /** 工具执行成功后触发的附加消息 */
     callbackMessage?: (result: CallToolResult) => Message[];
-    render?: <D>(tool: ToolRenderData<D>) => Child;
+    render?: <D>(tool: ToolRenderData<z.objectOutputType<Args, ZodTypeAny>, D>) => Child;
     onlyRender?: boolean;
     /** 只允许指定的 agent 使用该工具，如果未指定，则所有 agent 都可以使用 */
     allowAgent?: string[];
@@ -54,10 +54,10 @@ export declare const createMCPTool: <Args extends ZodRawShape>(tool: UnionTool<A
 }>))[];
 export declare const createToolUI: <Args extends Parameter[] | [] = [], Child extends Object = {}>(tool: Action<Args> & {
     allowAgent?: string[];
-    render?: (tool: ToolRenderData<any>) => Child;
+    render?: (tool: ToolRenderData<any, any>) => Child;
     onlyRender?: boolean;
 }) => {
-    render: ((tool: ToolRenderData<any>) => Child) | undefined;
+    render: ((tool: ToolRenderData<any, any>) => Child) | undefined;
     onlyRender: boolean | undefined;
     name: string;
     description: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langgraph-js/sdk",
-  "version": "1.7.1",
+  "version": "1.7.5",
   "description": "The UI SDK for LangGraph - seamlessly integrate your AI agents with frontend interfaces",
   "main": "dist/index.js",
   "type": "module",
@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@langchain/langgraph-sdk": "^0.0.77",
+    "jsonrepair": "^3.12.0",
     "nanostores": "^1.0.1",
     "zod": "^3.25.17",
     "zod-to-json-schema": "^3.24.5"